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

package/lib/plugins/newi18nsplitplugin/ChunkManager.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChunkManager = void 0;
+
+// ChunkManager.js
+class ChunkManager {
+  constructor(options) {
+    this.maxChunkSize = options.maxChunkSize;
+    this.minChunkSize = options.minChunkSize;
+    this.chunkGroups = new Map(); // Track related keys
+  }
+  splitChunk(chunkId, keys, numChunks) {
+    // Group related keys first
+    const groups = this.groupRelatedKeys(keys);
+    const newChunks = []; // Create new chunks
+
+    for (let i = 0; i < numChunks; i++) {
+      newChunks.push({
+        id: `${chunkId}_${i}`,
+        keys: [],
+        size: 0
+      });
+    } // Distribute groups to chunks to maintain key locality
+
+    groups.forEach(group => {
+      const targetChunk = this.findBestChunkForGroup(newChunks, group);
+      if (targetChunk) {
+        targetChunk.keys.push(...group);
+        targetChunk.size += group.length;
+      }
+    }); // Balance remaining individual keys
+
+    const ungroupedKeys = this.getUngroupedKeys(keys, groups);
+    this.distributeKeys(ungroupedKeys, newChunks);
+    return newChunks;
+  }
+  groupRelatedKeys(keys) {
+    const groups = [];
+    const keyPrefix = new Map(); // Group by common prefixes first
+
+    keys.forEach(key => {
+      const prefix = key.split('.')[0];
+      if (!keyPrefix.has(prefix)) {
+        keyPrefix.set(prefix, []);
+      }
+      keyPrefix.get(prefix).push(key);
+    }); // Create groups based on size constraints
+
+    keyPrefix.forEach((prefixKeys, prefix) => {
+      if (prefixKeys.length <= this.maxChunkSize) {
+        groups.push(prefixKeys);
+      } else {
+        // Split large prefix groups
+        const numSubgroups = Math.ceil(prefixKeys.length / this.maxChunkSize);
+        const subgroupSize = Math.ceil(prefixKeys.length / numSubgroups);
+        for (let i = 0; i < prefixKeys.length; i += subgroupSize) {
+          groups.push(prefixKeys.slice(i, i + subgroupSize));
+        }
+      }
+    });
+    return groups;
+  }
+  findBestChunkForGroup(chunks, group) {
+    let bestChunk = null;
+    let bestScore = -1;
+    chunks.forEach(chunk => {
+      const score = this.calculateChunkScore(chunk, group);
+      if (score > bestScore) {
+        bestScore = score;
+        bestChunk = chunk;
+      }
+    });
+    return bestChunk;
+  }
+  calculateChunkScore(chunk, group) {
+    // Score based on:
+    // 1. Available space
+    // 2. Related keys already in chunk
+    // 3. Chunk balance
+    const availableSpace = this.maxChunkSize - chunk.size;
+    if (availableSpace < group.length) return -1;
+    let score = 100 * (availableSpace / this.maxChunkSize); // Check for related keys
+
+    const relatedKeys = this.countRelatedKeys(chunk.keys, group);
+    score += relatedKeys * 10;
+    return score;
+  }
+  countRelatedKeys(existingKeys, newKeys) {
+    let count = 0;
+    const prefixes = new Set(newKeys.map(key => key.split('.')[0]));
+    existingKeys.forEach(key => {
+      if (prefixes.has(key.split('.')[0])) count++;
+    });
+    return count;
+  }
+  distributeKeys(keys, chunks) {
+    // Sort chunks by available space
+    chunks.sort((a, b) => this.maxChunkSize - a.size - (this.maxChunkSize - b.size));
+    keys.forEach(key => {
+      const targetChunk = chunks.find(chunk => chunk.size < this.maxChunkSize);
+      if (targetChunk) {
+        targetChunk.keys.push(key);
+        targetChunk.size++;
+      }
+    });
+  }
+  mergeChunks(chunk1Id, chunk2Id) {
+    const chunk1 = this.chunkGroups.get(chunk1Id);
+    const chunk2 = this.chunkGroups.get(chunk2Id);
+    if (!chunk1 || !chunk2) return null;
+    const combinedSize = chunk1.size + chunk2.size;
+    if (combinedSize > this.maxChunkSize) return null;
+    const mergedChunk = {
+      id: `${chunk1Id}_${chunk2Id}_merged`,
+      keys: [...chunk1.keys, ...chunk2.keys],
+      size: combinedSize
+    };
+    this.chunkGroups.delete(chunk1Id);
+    this.chunkGroups.delete(chunk2Id);
+    this.chunkGroups.set(mergedChunk.id, mergedChunk);
+    return mergedChunk;
+  }
+  getUngroupedKeys(allKeys, groups) {
+    const groupedKeys = new Set(groups.flat());
+    return allKeys.filter(key => !groupedKeys.has(key));
+  }
+}
+exports.ChunkManager = ChunkManager;

package/lib/plugins/newi18nsplitplugin/GenerateModuleIdToKeysMapPlugin.js

@@ -0,0 +1,59 @@
+"use strict";
+
+// GenerateModuleIdToKeysMapPlugin.js (Updated)
+const fs = require('fs');
+const path = require('path');
+class GenerateModuleIdToKeysMapPlugin {
+  constructor(options = {}) {
+    this.moduleToKeysMapPath = options.moduleToKeysMapPath || 'module_to_keys_map.json';
+    this.outputPath = options.outputPath || 'module_id_to_keys_map.json';
+  }
+  apply(compiler) {
+    compiler.hooks.emit.tapAsync('GenerateModuleIdToKeysMapPlugin', (compilation, callback) => {
+      console.log('[GenerateModuleIdToKeysMapPlugin] Plugin is running.'); // Load the existing module_to_keys_map.json
+
+      let moduleToKeysMap;
+      try {
+        const data = fs.readFileSync(this.moduleToKeysMapPath, 'utf8');
+        moduleToKeysMap = JSON.parse(data); // console.log('[GenerateModuleIdToKeysMapPlugin] moduleToKeysMap loaded.');
+      } catch (error) {
+        // console.error(`[GenerateModuleIdToKeysMapPlugin] Error reading ${this.moduleToKeysMapPath}:`, error);
+        moduleToKeysMap = {};
+      }
+      const projectRoot = path.resolve(__dirname, '..'); // Adjust '..' as needed
+      // Build a mapping from module relative paths to module IDs
+
+      const modulePathToIdMap = new Map();
+      for (const module of compilation.modules) {
+        if (module.resource) {
+          const moduleResource = module.resource;
+          const relativeModuleResource = path.relative(projectRoot, moduleResource).replace(/\\/g, '/').toLowerCase();
+          const moduleId = module.id;
+          modulePathToIdMap.set(relativeModuleResource, moduleId);
+        }
+      } //  console.log('[GenerateModuleIdToKeysMapPlugin] Available module paths and IDs:');
+
+      for (const [modulePath, moduleId] of modulePathToIdMap.entries()) {//  console.log(`Module Path: ${modulePath}, Module ID: ${moduleId}`);
+      } // Transform module paths in moduleToKeysMap to module IDs
+
+      const moduleIdToKeysMap = {};
+      for (const [modulePath, keysData] of Object.entries(moduleToKeysMap)) {
+        const normalizedModulePath = modulePath.replace(/\\/g, '/').toLowerCase();
+        const moduleId = modulePathToIdMap.get(normalizedModulePath);
+        if (moduleId == null) {
+          // console.warn(`[GenerateModuleIdToKeysMapPlugin] Module ID not found for path: ${normalizedModulePath}`);
+          continue;
+        }
+        const moduleIdString = String(moduleId);
+        moduleIdToKeysMap[moduleIdString] = keysData;
+      } // Write the module_id_to_keys_map.json
+
+      try {
+        fs.writeFileSync(this.outputPath, JSON.stringify(moduleIdToKeysMap, null, 2), 'utf8'); //   console.log(`[GenerateModuleIdToKeysMapPlugin] Generated ${this.outputPath}`);
+      } catch (error) {//  console.error(`[GenerateModuleIdToKeysMapPlugin] Error writing ${this.outputPath}:`, error);
+      }
+      callback();
+    });
+  }
+}
+module.exports = GenerateModuleIdToKeysMapPlugin;

package/lib/plugins/newi18nsplitplugin/I18nDiffPlugin.js

@@ -0,0 +1,262 @@
+"use strict";
+
+// const { RawSource } = require('webpack-sources');
+// const fs = require('fs');
+// const path = require('path');
+// //const axios = require('axios');
+// class I18nDiffPlugin {
+//   constructor(options = {}) {
+//     const {
+//       localMetaManifestPath,
+//       liveMetaManifestUrl,
+//       i18nAssetsOutputPath,
+//       i18nDataPath,
+//       locales = [],
+//     } = options;
+//     if (!localMetaManifestPath || !liveMetaManifestUrl || !i18nDataPath) {
+//       throw new Error('I18nDiffPlugin: Missing required options.');
+//     }
+//     this.localMetaManifestPath = localMetaManifestPath;
+//     this.liveMetaManifestUrl = liveMetaManifestUrl;
+//     this.i18nAssetsOutputPath = i18nAssetsOutputPath || 'dist/i18n-diff-chunks';
+//     this.i18nDataPath = i18nDataPath;
+//     this.locales = locales;
+//   }
+//   apply(compiler) {
+//     compiler.hooks.emit.tapAsync('I18nDiffPlugin', async (compilation, callback) => {
+//       try {
+//         // Step 1: Fetch the live CDN meta manifest
+//       //  const liveManifest = await this.fetchLiveManifest();
+//       const liveManifest = fs.readFileSync("./metaManifest.json", 'utf-8');
+//         // Step 2: Read the local meta manifest
+//         const localManifest = this.readLocalManifest();
+//         // Step 3: Compare manifests to find new or moved keys
+//         const diffKeys = this.compareManifests(localManifest, liveManifest);
+//         if (diffKeys.length === 0) {
+//           console.log('I18nDiffPlugin: No new or moved i18n keys detected.');
+//           return callback();
+//         }
+//         console.log(`I18nDiffPlugin: Found ${diffKeys.length} new or moved i18n keys.`);
+//         // Step 4: Generate i18n chunks for the diff keys
+//         await this.generateI18nChunks(compilation, diffKeys);
+//         // Step 5: Include chunks in build output (handled by emitting assets)
+//         callback();
+//       } catch (error) {
+//         console.error('I18nDiffPlugin: Error during processing:', error);
+//         callback(error);
+//       }
+//     });
+//   }
+// //   async fetchLiveManifest() {
+// //     console.log('I18nDiffPlugin: Fetching live CDN meta manifest...');
+// //     const response = await axios.get(this.liveMetaManifestUrl);
+// //     return response.data;
+// //   }
+//   readLocalManifest() {
+//     console.log('I18nDiffPlugin: Reading local meta manifest...');
+//     const manifestContent = fs.readFileSync(this.localMetaManifestPath, 'utf-8');
+//     return JSON.parse(manifestContent);
+//   }
+//   compareManifests(localManifest, liveManifest) {
+//     const localKeys = new Set(Object.keys(localManifest));
+//     const liveKeys = new Set(Object.keys(liveManifest));
+//     // Identify keys that are in local but not in live (new or moved keys)
+//     const diffKeys = [...localKeys].filter((key) => !liveKeys.has(key));
+//     return diffKeys;
+//   }
+//   async generateI18nChunks(compilation, diffKeys) {
+//     console.log('I18nDiffPlugin: Generating i18n chunks for new or moved keys...');
+//     for (const locale of this.locales) {
+//       const localeData = await this.loadLocaleData(locale);
+//       const i18nData = {};
+//       for (const key of diffKeys) {
+//         if (localeData[key]) {
+//           i18nData[key] = localeData[key];
+//         } else {
+//           console.warn(`I18nDiffPlugin: Key "${key}" not found in locale "${locale}" data.`);
+//         }
+//       }
+//       const chunkContent = `window.loadI18nChunk(${JSON.stringify(i18nData)});`;
+//       const chunkFilename = `${this.i18nAssetsOutputPath}/${locale}/i18n-diff-chunk.js`;
+//       // Ensure the path exists
+//       const outputPath = path.dirname(chunkFilename);
+//       if (!fs.existsSync(outputPath)) {
+//         fs.mkdirSync(outputPath, { recursive: true });
+//       }
+//       // Emit the chunk
+//       compilation.assets[chunkFilename] = new RawSource(chunkContent);
+//     }
+//   }
+//   async loadLocaleData(locale) {
+//     const localeFilePath = path.join(this.i18nDataPath, `${locale}.json`);
+//     if (!fs.existsSync(localeFilePath)) {
+//       throw new Error(`I18nDiffPlugin: Locale data file not found for "${locale}" at "${localeFilePath}".`);
+//     }
+//     const content = fs.readFileSync(localeFilePath, 'utf-8');
+//     return JSON.parse(content);
+//   }
+// }
+// module.exports = I18nDiffPlugin;
+const {
+  RawSource
+} = require('webpack-sources');
+const fs = require('fs');
+const path = require('path'); //const getI18nKeysFromModules = require('./utils/getI18nKeysFromModules');
+
+const {
+  convertUnicode
+} = require('../I18nSplitPlugin/utils/unicodeConversion');
+const pluginName = 'I18nDiffPlugin';
+class I18nDiffPlugin {
+  constructor(options = {}) {
+    const {
+      localMetaManifestPath,
+      liveMetaManifestPath,
+      i18nAssetsOutputPath,
+      i18nDataPath,
+      jsonpFunc
+    } = options;
+    if (!localMetaManifestPath || !liveMetaManifestPath || !i18nDataPath) {
+      throw new Error('I18nDiffPlugin: Missing required options.');
+    }
+    this.localMetaManifestPath = localMetaManifestPath;
+    this.liveMetaManifestPath = liveMetaManifestPath;
+    this.i18nAssetsOutputPath = i18nAssetsOutputPath || 'dist/i18n-diff-chunks';
+    this.i18nDataPath = i18nDataPath;
+    this.jsonpFunc = jsonpFunc || 'window.loadI18nChunk';
+    this.allI18nObject = {};
+    this.locales = [];
+  }
+  apply(compiler) {
+    compiler.hooks.emit.tapAsync(pluginName, (compilation, callback) => {
+      try {
+        // Step 1: Load the live CDN meta manifest
+        // const liveManifest = this.loadManifest(this.liveMetaManifestPath);
+        const liveManifest = this.loadManifest("./metaManifest.json"); // Step 2: Read the local meta manifest
+
+        const localManifest = this.loadManifest(this.localMetaManifestPath); // Step 3: Compare manifests to find new or moved keys
+
+        const {
+          newKeys,
+          movedKeys
+        } = this.compareManifests(localManifest, liveManifest);
+        const diffKeys = [...new Set([...newKeys, ...movedKeys])];
+        if (diffKeys.length === 0) {
+          console.log('I18nDiffPlugin: No new or moved i18n keys detected.');
+          return callback();
+        }
+        console.log(`I18nDiffPlugin: Found ${diffKeys.length} new or moved i18n keys.`);
+        console.log(`New keys: ${newKeys.join(', ')}`);
+        console.log(`Moved keys: ${movedKeys.join(', ')}`); // Step 4: Load all i18n data
+
+        this.loadAllI18nData(); // Step 5: Generate i18n chunks for the diff keys
+
+        this.generateI18nChunks(compilation, diffKeys);
+        callback();
+      } catch (error) {
+        console.error('I18nDiffPlugin: Error during processing:', error);
+        callback(error);
+      }
+    });
+  }
+  loadManifest(manifestPath) {
+    console.log(`I18nDiffPlugin: Loading manifest from ${manifestPath}...`);
+    const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+    return JSON.parse(manifestContent);
+  }
+  compareManifests(localManifest, liveManifest) {
+    const localKeys = Object.keys(localManifest.keyToCacheGroupMap);
+    const liveKeys = Object.keys(liveManifest.keyToCacheGroupMap);
+    const newKeys = localKeys.filter(key => !liveKeys.includes(key));
+    const movedKeys = localKeys.filter(key => {
+      if (liveKeys.includes(key)) {
+        const localGroups = localManifest.keyToCacheGroupMap[key];
+        const liveGroups = liveManifest.keyToCacheGroupMap[key];
+        return JSON.stringify(localGroups) !== JSON.stringify(liveGroups);
+      }
+      return false;
+    });
+    return {
+      newKeys,
+      movedKeys
+    };
+  } //   loadAllI18nData() {
+  //     console.log('I18nDiffPlugin: Loading all i18n data...');
+  //     const files = fs.readdirSync(this.i18nDataPath);
+  //     files.forEach((file) => {
+  //       const locale = path.basename(file, path.extname(file));
+  //       const localeFilePath = path.join(this.i18nDataPath, file);
+  //       const content = fs.readFileSync(localeFilePath, 'utf-8');
+  //       this.allI18nObject[locale] = JSON.parse(content);
+  //       this.locales.push(locale);
+  //     });
+  //     console.log(`I18nDiffPlugin: Locales found: ${this.locales.join(', ')}`);
+  //   }
+
+  loadAllI18nData() {
+    console.log('I18nDiffPlugin: Loading all i18n data...');
+    const files = fs.readdirSync(this.i18nDataPath);
+    files.forEach(file => {
+      const locale = path.basename(file, path.extname(file));
+      const localeFilePath = path.join(this.i18nDataPath, file);
+      const content = fs.readFileSync(localeFilePath, 'utf-8'); // Regular expression to match 'var i18n = {...};'
+
+      const regex = /var\s+i18n\s*=\s*(\{[\s\S]*\});?/;
+      const match = content.match(regex);
+      if (match && match[1]) {
+        const jsonString = match[1];
+        try {
+          const i18nData = eval('(' + jsonString + ')'); // Use eval carefully
+
+          this.allI18nObject[locale] = i18nData;
+          this.locales.push(locale);
+        } catch (err) {
+          console.error(`I18nDiffPlugin: Failed to parse i18n data in ${file}:`, err);
+        }
+      } else {
+        console.warn(`I18nDiffPlugin: Could not extract 'i18n' variable from ${file}`);
+      }
+    });
+    console.log(`I18nDiffPlugin: Locales found: ${this.locales.join(', ')}`);
+  }
+  generateI18nChunks(compilation, diffKeys) {
+    console.log('I18nDiffPlugin: Generating i18n chunks for new or moved keys...');
+    const chunkName = 'i18n-diff-chunk'; // For each locale, generate the i18n chunk
+
+    this.locales.forEach(locale => {
+      const i18nData = this.getI18nObjectByLocale(diffKeys, locale);
+      const moduleSource = this.getTemplateString(i18nData);
+      const filename = path.join(this.i18nAssetsOutputPath, locale, `${chunkName}.js`); // Ensure the path exists
+
+      const outputPath = path.dirname(filename);
+      if (!fs.existsSync(outputPath)) {
+        fs.mkdirSync(outputPath, {
+          recursive: true
+        });
+      } // Emit the chunk
+
+      compilation.assets[filename] = new RawSource(moduleSource);
+    });
+  }
+  getI18nObjectByLocale(i18nKeys, locale) {
+    const data = {};
+    i18nKeys.forEach(key => {
+      if (this.allI18nObject[locale][key]) {
+        data[key] = this.allI18nObject[locale][key];
+      } else {
+        console.warn(`I18nDiffPlugin: Key "${key}" not found in locale "${locale}" data.`);
+      }
+    });
+    return data;
+  }
+  getTemplateString(i18nObject) {
+    // const convertedI18nObject = convertUnicode(
+    //   JSON.stringify(i18nObject, null, 0)
+    // );
+    const jsonString = JSON.stringify(i18nObject); //console.log('i18nObject:', i18nObject);
+
+    console.log('jsonString:', jsonString);
+    return `${this.jsonpFunc}(${jsonString});`;
+  }
+}
+module.exports = I18nDiffPlugin;

package/lib/plugins/newi18nsplitplugin/I18nDownloadLogic.js

@@ -0,0 +1,166 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _webpack = require("webpack");
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+// import { Template } from 'webpack';
+// const pluginName = 'I18nDownloadLogic';
+// export default class I18nDownloadLogic {
+//   constructor({ localeVarName = 'document.documentElement.lang', publicPath = '' }) {
+//     this.options = {
+//       localeVarName,
+//       publicPath: publicPath.endsWith('/') ? publicPath : publicPath + '/'
+//     };
+//   }
+//   apply(compiler) {
+//     compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+//       const { mainTemplate } = compilation;
+//       mainTemplate.hooks.requireEnsure.tap(pluginName, (source, chunk, hash) => {
+//         return Template.asString([
+//           source.replace(
+//             'var promise = new Promise(function(resolve, reject) {',
+//             'var originalPromise = new Promise(function(resolve, reject) {'
+//           ),
+//           '',
+//           '// I18n chunk loading logic',
+//           '(function(chunkId, promises) {',
+//           Template.indent([
+//             `var locale = ${this.options.localeVarName};`,
+//             'if (!__webpack_require__.i18n) {',
+//             Template.indent([
+//               '__webpack_require__.i18n = {',
+//               '  loaded: {},',
+//               '  manifest: null,',
+//               '  manifestLoading: null,',
+//               '  loadManifest: function() {',
+//               '    var self = this;',
+//               '    if (this.manifest) return Promise.resolve(this.manifest);',
+//               '    if (this.manifestLoading) return this.manifestLoading;',
+//               '',
+//               '    console.log("[I18N] Fetching manifest...");',
+//               '    this.manifestLoading = fetch(__webpack_require__.p + "i18n-manifest.json")',
+//               '      .then(function(res) {',
+//               '        if (!res.ok) throw new Error("Failed to load manifest: " + res.status);',
+//               '        return res.json();',
+//               '      })',
+//               '      .then(function(data) {',
+//               '        console.log("[I18N] Manifest loaded:", data);',
+//               '        self.manifest = data;',
+//               '        self.manifestLoading = null;',
+//               '        return data;',
+//               '      })',
+//               '      .catch(function(error) {',
+//               '        console.error("[I18N] Manifest load failed:", error);',
+//               '        self.manifestLoading = null;',
+//               '        throw error;',
+//               '      });',
+//               '',
+//               '    return this.manifestLoading;',
+//               '  },',
+//               '  getChunkI18nFile: function(chunkId, locale) {',
+//               '    try {',
+//               '      if (!this.manifest || !this.manifest.locales) return null;',
+//               '      var localeData = this.manifest.locales[locale];',
+//               '      return localeData && localeData[chunkId];',
+//               '    } catch (e) {',
+//               '      console.error("[I18N] Error getting chunk file:", e);',
+//               '      return null;',
+//               '    }',
+//               '  },',
+//               '  loadChunkI18n: function(chunkId, locale) {',
+//               '    var self = this;',
+//               '    var key = chunkId + "_" + locale;',
+//               '',
+//               '    if (this.loaded[key]) {',
+//               '      return Promise.resolve();',
+//               '    }',
+//               '',
+//               '    return new Promise(function(resolve, reject) {',
+//               '      var i18nFile = self.getChunkI18nFile(chunkId, locale);',
+//               '      if (!i18nFile) {',
+//               '        // Not an error - this chunk might not have i18n data',
+//               '        console.log("[I18N] No i18n file for chunk:", chunkId);',
+//               '        resolve();',
+//               '        return;',
+//               '      }',
+//               '',
+//               '      var script = document.createElement("script");',
+//               '      script.charset = "utf-8";',
+//               '      script.setAttribute("data-chunk-id", chunkId);',
+//               '',
+//               '      script.onload = function() {',
+//               '        self.loaded[key] = true;',
+//               '        resolve();',
+//               '      };',
+//               '',
+//               '      script.onerror = function(error) {',
+//               '        console.error("[I18N] Failed to load chunk i18n:", chunkId, error);',
+//               '        // Don\'t reject - we don\'t want to block chunk loading',
+//               '        resolve();',
+//               '      };',
+//               '',
+//               '      script.src = __webpack_require__.p + i18nFile;',
+//               '      document.head.appendChild(script);',
+//               '    });',
+//               '  }',
+//               '};'
+//             ]),
+//             '}',
+//             '',
+//             '// Load i18n data for this chunk if needed',
+//             'if (promises && Array.isArray(promises)) {',
+//             '  promises.push(',
+//             '    __webpack_require__.i18n.loadManifest()',
+//             '      .then(function() {',
+//             '        return __webpack_require__.i18n.loadChunkI18n(chunkId, locale);',
+//             '      })',
+//             '      .catch(function(error) {',
+//             '        console.warn("[I18N] Failed to load i18n for chunk:", chunkId, error);',
+//             '      })',
+//             '  );',
+//             '}'
+//           ]),
+//           '})(__webpack_require__.u ? chunkId : (typeof chunkId === "number" ? "" + chunkId : chunkId), promises);'
+//         ]);
+//       });
+//     });
+//   }
+// }
+const pluginName = 'I18nDownloadLogic';
+class I18nDownloadLogic {
+  constructor({
+    filenameTemplate = 'i18n-chunk/[locale]/[name].[chunkhash].i18n.js',
+    publicPath = '',
+    localeVarName = 'document.documentElement.lang',
+    locales = []
+  }) {
+    this.locales = locales;
+    this.publicPath = publicPath;
+    this.options = {
+      filenameTemplate,
+      localeVarName
+    };
+  }
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+      const {
+        mainTemplate
+      } = compilation;
+      mainTemplate.hooks.requireEnsure.tap(pluginName, (source, chunk, hash) => {
+        return _webpack.Template.asString([source, '', '// I18n chunk loading logic', '(function() {', _webpack.Template.indent([
+        // Initialize loading state tracking
+        'if (!__webpack_require__.i18n) {', _webpack.Template.indent(['__webpack_require__.i18n = {', '  // Track loaded chunks by locale', '  loaded: {},', '', '  // Current and fallback manifests', '  manifest: null,', '  fallbackManifest: null,', '', '  // Load manifest with fallback support', '  loadManifest: function() {', '    var self = this;', '    if (this.manifest) return Promise.resolve(this.manifest);', '', '    return fetch(__webpack_require__.p + "i18n-manifest.json")', '      .then(function(res) {', '        if (!res.ok) throw new Error("No manifest");', '        return res.json();', '      })', '      .then(function(data) {', '        self.manifest = data;', '        return data;', '      })', '      .catch(function(error) {', '        return fetch(__webpack_require__.p + "i18n-manifest.main.json")', '          .then(function(res) { return res.json(); })', '          .then(function(data) {', '            self.fallbackManifest = data;', '            return self.manifest || data;', '          });', '      });', '  },', '', '  // Find which chunk contains a key', '  findChunkForKey: function(key) {', '    // Check current manifest first', '    if (this.manifest && this.manifest.chunks) {', '      for (var chunk in this.manifest.chunks) {', '        if (this.manifest.chunks[chunk].includes(key)) {', '          return chunk;', '        }', '      }', '    }', '', '    // Check key movement history', '    if (this.manifest && this.manifest.keyMovements && this.manifest.keyMovements[key]) {', '      return this.manifest.keyMovements[key].newChunk;', '    }', '', '    // Check fallback manifest', '    if (this.fallbackManifest && this.fallbackManifest.chunks) {', '      for (var chunk in this.fallbackManifest.chunks) {', '        if (this.fallbackManifest.chunks[chunk].includes(key)) {', '          return chunk;', '        }', '      }', '    }', '', '    return null;', '  },', '', '  // Get all keys for a chunk including moved keys', '  loadChunkKeys: function(chunkId) {', '    var keys = [];', '    if (this.manifest && this.manifest.chunks[chunkId]) {', '      keys = keys.concat(this.manifest.chunks[chunkId]);', '    }', '', '    // Add keys that were moved to this chunk', '    if (this.manifest && this.manifest.keyMovements) {', '      Object.entries(this.manifest.keyMovements)', '        .forEach(function([key, movement]) {', '          if (movement.newChunk === chunkId) {', '            keys.push(key);', '          }', '        });', '    }', '', '    return keys;', '  },', '', '  // Load a chunk for a specific locale', '  loadLocaleChunk: function(chunkId, locale) {', '    var self = this;', '    var loadedKey = chunkId + "_" + locale;', '', '    if (self.loaded[loadedKey]) {', '      return Promise.resolve();', '    }', '', '    return this.loadManifest().then(function(manifest) {', '      var chunkPath = manifest.locales[locale][chunkId];', '      if (!chunkPath) {', '        console.warn("No i18n chunk found for", {chunkId: chunkId, locale: locale});', '        return Promise.resolve();', '      }', '', '      return new Promise(function(resolve, reject) {', '        var script = document.createElement("script");', '        script.charset = "utf-8";', '        script.timeout = 120;', '        script.src = __webpack_require__.p + chunkPath;', '', '        var timeout = setTimeout(function() {', '          onScriptError({ type: "timeout", target: script });', '        }, 120000);', '', '        function onScriptComplete() {', '          script.onerror = script.onload = null;', '          clearTimeout(timeout);', '          self.loaded[loadedKey] = true;', '          resolve();', '        }', '', '        function onScriptError(event) {', '          script.onerror = script.onload = null;', '          clearTimeout(timeout);', '          var errorType = event && event.type;', '          var realSrc = event && event.target && event.target.src;', '          var error = new Error("Loading i18n chunk " + chunkId + " failed.\\n(" + errorType + ": " + realSrc + ")");', '          error.type = errorType;', '          error.request = realSrc;', '          reject(error);', '        }', '', '        script.onerror = onScriptError;', '        script.onload = onScriptComplete;', '', '        document.head.appendChild(script);', '      });', '    });', '  }', '};']), '}', '', '// Load i18n for the current chunk', 'var locale = ' + this.options.localeVarName + ';', 'if (locale && chunkId) {', _webpack.Template.indent(['promises.push(__webpack_require__.i18n.loadLocaleChunk(chunkId, locale));']), '}']), '})();']);
+      });
+    });
+  }
+}
+exports.default = I18nDownloadLogic;