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

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

@@ -0,0 +1,279 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyMetaManifest = applyMetaManifest;
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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
+    };
+  }
+}

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

@@ -5,11 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.collectI18nKeysfromAST = collectI18nKeysfromAST;
 exports.collectI18nKeysfromComments = collectI18nKeysfromComments;
-
 const {
   walk
 } = require('estree-walker');
-
 function collectI18nKeysfromAST(ast, allI18n) {
   let i18nKeys = {};
   walk(ast, {
@@ -23,42 +21,34 @@ function collectI18nKeysfromAST(ast, allI18n) {
   });
   return Object.keys(i18nKeys);
 }
-
 const prefixI18nComment = 'I18N';
 const prefixI18nComment1 = 'dynamic-i18n-key';
-
 function getI18nKeysFromComment(comment) {
   let commentString = comment.value.trim();
   let i18nKeyStr;
-
   if (commentString.startsWith(prefixI18nComment)) {
     i18nKeyStr = commentString.slice(prefixI18nComment.length).trim();
   } else if (commentString.startsWith(prefixI18nComment1)) {
     i18nKeyStr = commentString.slice(prefixI18nComment1.length).trim();
   }
-
   if (!i18nKeyStr) {
     return [];
   }
-
   const i18nKeys = i18nKeyStr.split(',');
   return i18nKeys;
-} // export function fromComments(comments, allI18n) {
-
+}
 
+// export function fromComments(comments, allI18n) {
 function collectI18nKeysfromComments(comments, allI18n) {
   // TODO: need to implement
   let i18nKeys = {};
-
   for (let comment of comments) {
     let keys = getI18nKeysFromComment(comment);
-
     for (let key of keys) {
       if (key && allI18n[key]) {
         i18nKeys[key] = allI18n[key];
       }
     }
   }
-
   return Object.keys(i18nKeys);
 }

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

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMetaManifest = createMetaManifest;
+var _webpackSources = require("webpack-sources");
+function createMetaManifest(compilation, plugin, skipEmit = false) {
+  const {
+    detailedManifest
+  } = plugin;
+  const i18nMetaManifestFileName = plugin.i18nMetaManifestFileName;
+  if (!skipEmit) {
+    console.log('Generating meta manifest:', i18nMetaManifestFileName);
+  }
+  const finalMetaManifest = {
+    modules: {}
+  };
+  for (const [chunkId, chunkData] of Object.entries(detailedManifest)) {
+    const chunkName = chunkData.chunkName || `chunk_${chunkId}`;
+    const keysArray = Array.isArray(chunkData.keysUsed) ? chunkData.keysUsed : Array.from(chunkData.keysUsed);
+    if (keysArray.length > 0) {
+      finalMetaManifest.modules[chunkName] = {
+        id: chunkId,
+        keys: keysArray
+      };
+    }
+  }
+  if (plugin.extraKeys && plugin.movedKeys) {
+    const masterKeysSet = new Set([...(Array.from(plugin.extraKeys) || []), ...(Array.from(plugin.movedKeys) || [])]);
+    finalMetaManifest.masterKeys = Array.from(masterKeysSet);
+    if (finalMetaManifest.masterKeys.length > 0) {
+      console.log(`Extra and moved keys to add to master chunk: ${finalMetaManifest.masterKeys.length}`);
+      finalMetaManifest.masterKeys.forEach(key => {
+        console.log(`  - ${key}`);
+      });
+    }
+  }
+  plugin.generatedMetaManifest = finalMetaManifest;
+  if (!skipEmit) {
+    const metaManifestSource = new _webpackSources.RawSource(JSON.stringify(finalMetaManifest, null, 2));
+    if (!compilation.emitAsset) {
+      compilation.assets[i18nMetaManifestFileName] = metaManifestSource;
+    } else {
+      compilation.emitAsset(i18nMetaManifestFileName, metaManifestSource, {
+        desc: 'Streamlined chunk-module-i18nKeys mapping with optimized master keys'
+      });
+    }
+  }
+  return finalMetaManifest;
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRegularManifest = createRegularManifest;
+var _webpackSources = require("webpack-sources");
+function createRegularManifest(compilation, plugin) {
+  const {
+    regularManifest,
+    // e.g., { chunkId: { localeA: pathA, localeB: pathB, ... }, ... }
+    locales,
+    // e.g., ['en_US', 'fr_FR', ...]
+    i18nManifestFileName,
+    // e.g., 'i18n-manifest.json'
+    deskI18nManifestFileName = 'i18n-chunk/desk-i18n-manifest.js'
+  } = plugin;
+  const finalManifest = {
+    locales: [...locales],
+    chunks: {},
+    basePath: 'i18n-chunk/[locale]/'
+  };
+  for (const chunkId of Object.keys(regularManifest)) {
+    const localePaths = regularManifest[chunkId];
+    if (!localePaths) continue;
+    const entries = Object.entries(localePaths);
+    if (!entries.length) continue;
+    const [someLocale, fullPath] = entries[0];
+    if (!fullPath) continue;
+    const pathSegments = fullPath.split('/');
+    const basename = pathSegments.slice(2).join('/');
+    finalManifest.chunks[chunkId] = basename;
+  }
+  const manifestStr = JSON.stringify(finalManifest, null, 2);
+  const jsonManifestSource = new _webpackSources.RawSource(manifestStr);
+  const deskI18nManifestCode = `
+    (function() {
+      window.desk_i18n_manifest = ${manifestStr};
+    })();
+  `;
+  const deskI18nManifestSource = new _webpackSources.RawSource(deskI18nManifestCode);
+  compilation.emitAsset(i18nManifestFileName, jsonManifestSource, {
+    desc: 'Emitted plain JSON i18n manifest'
+  });
+  compilation.emitAsset(deskI18nManifestFileName, deskI18nManifestSource, {
+    desc: 'Emitted manifest attached to window.desk_i18n_manifest'
+  });
+}

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getI18nFileUrlPathTemplate = getI18nFileUrlPathTemplate;
-
 function getI18nFileUrlPathTemplate(compilation, chunk, filenameTemplate, localeTemplate) {
   let urlpath = compilation.getPath(filenameTemplate, {
     chunk

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

@@ -4,23 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = getI18nKeysFormModules;
-
 var _I18nDependency = require("../I18nDependency");
-
 function getI18nKeysFormModules(modules) {
   const i18nTemObj = {};
-
   for (let m of modules) {
     for (let dep of m.dependencies) {
       if (!(dep instanceof _I18nDependency.I18nDependency)) {
         continue;
       }
-
       for (const key of dep.i18nKeys) {
         i18nTemObj[key] = 1;
       }
     }
   }
-
   return Object.keys(i18nTemObj);
 }

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

@@ -6,32 +6,25 @@ Object.defineProperty(exports, "__esModule", {
 exports.REGEXP_CONTENTHASH = void 0;
 exports.getShortI18nAssets = getShortI18nAssets;
 exports.hasContentHash = hasContentHash;
-
 var _urlConcat = require("../../../utils/urlConcat");
-
 // export const REGEXP_CHUNKHASH = /\[chunkhash(?::(\d+))?\]/gi;
 // export const REGEXP_HASH = /\[hash(?::(\d+))?\]/gi;
 // export const REGEXP_NAME = /\[name\]/gi;
 // export const REGEXP_PLACEHOLDERS = /\[(name|id|chunkhash)\]/gi;
 // TODO: want to choose file type for i18n load
-const REGEXP_CONTENTHASH = /\[contenthash(?::(\d+))?\]/gi;
-exports.REGEXP_CONTENTHASH = REGEXP_CONTENTHASH;
-
+const REGEXP_CONTENTHASH = exports.REGEXP_CONTENTHASH = /\[contenthash(?::(\d+))?\]/gi;
 function hasContentHash(filenameTemplate) {
   return REGEXP_CONTENTHASH.test(filenameTemplate);
 }
-
 function getShortI18nAssets(chunks, i18nManifest, publicPathPrefix) {
   const i18nAssets = {};
   chunks.forEach(chunk => {
     const i18nFiles = i18nManifest[chunk.id];
-
     if (i18nFiles) {
       Object.keys(i18nFiles).forEach(locale => {
         if (!i18nAssets[locale]) {
           i18nAssets[locale] = [];
         }
-
         i18nAssets[locale].push((0, _urlConcat.urlConcat)(publicPathPrefix, i18nFiles[locale]));
       });
     }

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

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
 var _collectI18nKeys = require("./collectI18nKeys");
-
 Object.keys(_collectI18nKeys).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _collectI18nKeys[key]) return;
@@ -16,9 +14,7 @@ Object.keys(_collectI18nKeys).forEach(function (key) {
     }
   });
 });
-
 var _propertiesUtils = require("./propertiesUtils");
-
 Object.keys(_propertiesUtils).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _propertiesUtils[key]) return;

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

@@ -6,19 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.getAllI18n = getAllI18n;
 exports.getPropertiesAsJSON = getPropertiesAsJSON;
 exports.jsonToString = jsonToString;
-
 var _fs = require("fs");
-
 var _path = require("path");
-
 var _logger = require("../../../logger");
-
 var _unicodeConversion = require("./unicodeConversion");
-
 function isComment(line) {
   return line[0] === '#';
 }
-
 function getPropertiesAsJSON(filePath) {
   try {
     const data = (0, _fs.readFileSync)(filePath);
@@ -26,16 +20,13 @@ function getPropertiesAsJSON(filePath) {
     const i18nObj = {};
     source.split(/\r?\n\r?/).forEach(fline => {
       const line = fline.trim();
-
       if (!line || isComment(line)) {
         return;
       }
-
       const ind = line.indexOf('=');
       const key = line.slice(0, ind).replace(/\\ /g, ' ');
       let value = line.slice(ind + 1);
       value = (0, _unicodeConversion.convertUnicode)(value);
-
       if (key && value) {
         i18nObj[key] = value;
       }
@@ -45,19 +36,15 @@ function getPropertiesAsJSON(filePath) {
     return {};
   }
 }
-
 function getLang(file) {
   const underScoreIndex = file.indexOf('_');
   let language = 'en_US';
-
   if (underScoreIndex !== -1) {
     language = file.substring(underScoreIndex + 1);
     language = language.slice(0, language.indexOf('.'));
   }
-
   return language;
 }
-
 function getAllI18n({
   folderPath,
   disableDefault,
@@ -71,11 +58,9 @@ function getAllI18n({
     const context = (0, _path.join)(process.cwd(), folderPath);
     files.forEach(file => {
       const filePath = (0, _path.join)(context, file);
-
       if (exclude.test(filePath) || !include.test(filePath)) {
         return;
       }
-
       const i18n = getPropertiesAsJSON(filePath);
       allLangI18n[getLang(file)] = disableDefault ? i18n : Object.assign({}, jsResourceI18nKeys, i18n);
     });
@@ -85,27 +70,22 @@ function getAllI18n({
     return {};
   }
 }
-
 function jsonToString(json, keySeperator) {
   let str = '{';
   const keys = Object.keys(json);
   keys.forEach((key, i) => {
     const value = json[key];
-
     if (!value) {
       return;
     }
-
     str += `"${keySeperator ? key.replace(/(\.|\\(\s+))/g, keySeperator) : key}":"${value.replace(/.?"/g, match => {
       if (match[0] === '\\') {
         return match;
       } else if (match.length === 2) {
         return `${match[0]}\\${match[1]}`;
       }
-
       return `\\${match}`;
     }).replace(/(\r\n|\n|\r)/g, '')}"`;
-
     if (i !== keys.length - 1) {
       str += ',';
     }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.convertUnicode = convertUnicode;
-
 function convertUnicode(str) {
   const unicodeRegex = /\\u([a-fA-F0-9]{4})/g;
   const converted = str.replace(unicodeRegex, (match, hex) => {