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

package/lib/plugins/newi18nsplitplugin/I18nPropertiesPlugin.js

@@ -0,0 +1,111 @@
+"use strict";
+
+// I18nPropertiesPlugin.js
+const fs = require('fs');
+const path = require('path');
+class I18nPropertiesPlugin {
+  constructor(options = {}) {
+    // Default options
+    this.options = Object.assign({
+      propertiesDir: '',
+      // Directory containing .properties files
+      outputDir: 'i18n',
+      // Output directory in the build output
+      outputFormat: 'json',
+      // Output format: 'json' or 'js'
+      encoding: 'utf8' // File encoding
+    }, options);
+  }
+  apply(compiler) {
+    compiler.hooks.thisCompilation.tap('I18nPropertiesPlugin', compilation => {
+      compilation.hooks.processAssets.tapAsync({
+        name: 'I18nPropertiesPlugin',
+        stage: compilation.constructor.PROCESS_ASSETS_STAGE_ADDITIONS
+      }, (assets, callback) => {
+        this.processPropertiesFiles(compilation).then(() => callback()).catch(error => callback(error));
+      });
+    });
+  }
+  async processPropertiesFiles(compilation) {
+    const propertiesDir = path.resolve(this.options.propertiesDir);
+    const files = await this.getPropertiesFiles(propertiesDir);
+    for (const file of files) {
+      const content = fs.readFileSync(file, this.options.encoding);
+      const transformed = this.transformProperties(content);
+      const relativePath = path.relative(propertiesDir, file);
+      const outputFileName = this.getOutputFileName(relativePath);
+      const outputContent = this.getOutputContent(transformed); // Emit the file into the Webpack output
+
+      compilation.emitAsset(outputFileName, {
+        source: () => outputContent,
+        size: () => outputContent.length
+      });
+    }
+  }
+  async getPropertiesFiles(dir) {
+    const entries = fs.readdirSync(dir, {
+      withFileTypes: true
+    });
+    const files = [];
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...(await this.getPropertiesFiles(fullPath)));
+      } else if (entry.isFile() && entry.name.endsWith('.properties')) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  transformProperties(content) {
+    const properties = this.parseProperties(content);
+    const transformed = {};
+    for (const [key, value] of Object.entries(properties)) {
+      transformed[key] = this.convertUnicodeToNative(value);
+    }
+    return transformed;
+  }
+  parseProperties(content) {
+    const result = {};
+    const lines = content.split(/\r?\n/);
+    for (let line of lines) {
+      line = line.trim();
+      if (line && !line.startsWith('#')) {
+        const [key, ...valueParts] = line.split('=');
+        if (key && valueParts.length > 0) {
+          const value = valueParts.join('=').trim();
+          result[key.trim()] = value;
+        }
+      }
+    }
+    return result;
+  }
+  convertUnicodeToNative(str) {
+    return str.replace(/\\u([0-9a-fA-F]{4})/g, (match, hex) => {
+      try {
+        return String.fromCharCode(parseInt(hex, 16));
+      } catch (err) {
+        return match;
+      }
+    });
+  }
+  getOutputFileName(relativePath) {
+    const ext = path.extname(relativePath);
+    const baseName = path.basename(relativePath, ext);
+    const dirName = path.dirname(relativePath);
+    let outputFileName = `${baseName}.${this.options.outputFormat}`;
+    if (dirName && dirName !== '.') {
+      outputFileName = path.join(dirName, outputFileName);
+    }
+    return path.join(this.options.outputDir, outputFileName);
+  }
+  getOutputContent(transformed) {
+    if (this.options.outputFormat === 'json') {
+      return JSON.stringify(transformed, null, 2);
+    } else if (this.options.outputFormat === 'js') {
+      return `module.exports = ${JSON.stringify(transformed, null, 2)};`;
+    }
+    throw new Error(`Unsupported output format: ${this.options.outputFormat}`);
+  }
+}
+module.exports = I18nPropertiesPlugin;

package/lib/plugins/newi18nsplitplugin/KeyCollector.js

@@ -0,0 +1,163 @@
+"use strict";
+
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+const {
+  walk
+} = require('estree-walker');
+const {
+  RawSource
+} = require('webpack-sources');
+const parser = require('@babel/parser');
+const generate = require('@babel/generator').default;
+const pluginName = 'I18nKeyHashPlugin';
+class I18nKeyHashPlugin {
+  constructor(options = {}) {
+    const {
+      jsResourcePath
+    } = options;
+    if (!jsResourcePath) {
+      throw new Error('jsResourcePath is required');
+    }
+    this.jsResourcePath = jsResourcePath;
+    this.keyToHashMap = new Map();
+    this.processedFiles = new WeakSet();
+    this.preserveStringKeys = new Set(['Delete',
+    // Common UI strings that shouldn't be hashed
+    'Cancel', 'Save', 'Close']);
+  }
+  hashKey(key) {
+    // Don't hash preserved strings
+    if (this.preserveStringKeys.has(key)) {
+      return key;
+    }
+    if (this.keyToHashMap.has(key)) {
+      return this.keyToHashMap.get(key);
+    }
+    const hash = crypto.createHash('md5').update(key).digest('hex').substring(0, 7);
+    this.keyToHashMap.set(key, hash);
+    return hash;
+  }
+  loadI18nKeys() {
+    try {
+      const content = fs.readFileSync(this.jsResourcePath, 'utf8');
+      const i18nObj = {};
+      content.split(/\r?\n/).forEach(line => {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) return;
+        const ind = trimmedLine.indexOf('=');
+        if (ind <= 0) return;
+        const key = trimmedLine.slice(0, ind).trim();
+        const value = trimmedLine.slice(ind + 1).trim();
+        if (key && value) {
+          i18nObj[key] = value; // Pre-generate hash
+
+          this.hashKey(key);
+        }
+      });
+      return i18nObj;
+    } catch (err) {
+      return {};
+    }
+  }
+  safeGenerateCode(ast) {
+    try {
+      const result = generate(ast, {
+        retainLines: true,
+        compact: false,
+        concise: false,
+        quotes: 'single',
+        jsonCompatibleStrings: true
+      });
+      return result.code;
+    } catch (err) {
+      throw new Error(`Code generation failed: ${err.message}`);
+    }
+  }
+  processSafeStringLiteral(node, hash) {
+    // Handle template literals more carefully
+    if (node.type === 'TemplateLiteral') {
+      return; // Skip template literals for safety
+    } // Handle regular string literals
+
+    if ((node.type === 'StringLiteral' || node.type === 'Literal') && typeof node.value === 'string') {
+      node.value = hash;
+      node.raw = `'${hash}'`;
+      if (node.extra) {
+        node.extra.raw = `'${hash}'`;
+        node.extra.rawValue = hash;
+      }
+    }
+  }
+  processAST(ast, i18nKeys) {
+    let modified = false;
+    try {
+      walk(ast, {
+        enter: node => {
+          // Handle string literals in JSX attributes
+          if ((node.type === 'StringLiteral' || node.type === 'Literal') && typeof node.value === 'string' && i18nKeys[node.value]) {
+            const hash = this.hashKey(node.value);
+            this.processSafeStringLiteral(node, hash);
+            modified = true;
+          } // Handle JSXText differently
+
+          if (node.type === 'JSXText' && i18nKeys[node.value.trim()]) {
+            const key = node.value.trim();
+            const hash = this.hashKey(key);
+            node.value = hash;
+            modified = true;
+          }
+        }
+      });
+    } catch (err) {
+      throw new Error(`AST processing failed: ${err.message}`);
+    }
+    return modified;
+  }
+  apply(compiler) {
+    let i18nKeys;
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      if (!i18nKeys) {
+        i18nKeys = this.loadI18nKeys();
+      }
+      compilation.hooks.succeedModule.tap(pluginName, module => {
+        if (!module.resource || !/\.(js|jsx|ts|tsx)$/.test(module.resource) || this.processedFiles.has(module)) {
+          return;
+        }
+        try {
+          const source = module._source.source(); // Parse with more precise settings
+
+          const ast = parser.parse(source, {
+            sourceType: 'module',
+            plugins: ['jsx', 'typescript', 'classProperties', 'decorators-legacy'],
+            tokens: true,
+            errorRecovery: true
+          });
+          if (this.processAST(ast, i18nKeys)) {
+            const newCode = this.safeGenerateCode(ast);
+            module._source = new RawSource(newCode); // Update module hash
+
+            module.buildInfo.hash = crypto.createHash('md5').update(newCode).digest('hex');
+          }
+          this.processedFiles.add(module);
+        } catch (err) {
+          // Log error but don't fail the build
+          compilation.warnings.push(new Error(`[${pluginName}] Processing ${module.resource} failed: ${err.message}`));
+        }
+      }); // Generate manifest after processing
+
+      compilation.hooks.afterOptimizeModules.tap(pluginName, () => {
+        const manifest = {
+          hashMapping: Object.fromEntries(this.keyToHashMap),
+          metadata: {
+            totalKeys: this.keyToHashMap.size,
+            timestamp: Date.now()
+          }
+        };
+        compilation.assets['i18n-hash-manifest.json'] = new RawSource(JSON.stringify(manifest, null, 2));
+      });
+    });
+  }
+}
+module.exports = I18nKeyHashPlugin;

package/lib/plugins/newi18nsplitplugin/ManifestGenerator.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const {
+  RawSource
+} = require('webpack-sources');
+function generateManifests({
+  compilation,
+  allI18nKeys,
+  moduleToKeysMap,
+  cacheGroupToModulesMap,
+  jsResourceI18nKeys
+}) {
+  const manifest = {
+    cacheGroupToI18nMap: {},
+    locales: {}
+  };
+  const metaManifest = {
+    keyToCacheGroupMap: {}
+  };
+  const locales = Object.keys(allI18nKeys); // Map keys to cache groups
+
+  const keyToCacheGroupMap = {};
+  for (const [cacheGroupName, moduleResources] of cacheGroupToModulesMap.entries()) {
+    const cacheGroupI18nKeys = new Set();
+    for (const moduleResource of moduleResources) {
+      const keys = moduleToKeysMap.get(moduleResource);
+      if (keys) {
+        keys.forEach(key => {
+          if (jsResourceI18nKeys.hasOwnProperty(key)) {
+            cacheGroupI18nKeys.add(key); // Map key to cache group for meta manifest
+
+            if (!keyToCacheGroupMap[key]) {
+              keyToCacheGroupMap[key] = new Set();
+            }
+            keyToCacheGroupMap[key].add(cacheGroupName);
+          }
+        });
+      }
+    } // Generate i18n files per cache group and locale
+
+    for (const locale of locales) {
+      const i18nData = {};
+      const localeData = allI18nKeys[locale];
+      for (const key of cacheGroupI18nKeys) {
+        // Find the key in the locale data
+        let found = false;
+        for (const section of Object.values(localeData)) {
+          if (section.hasOwnProperty(key)) {
+            i18nData[key] = section[key];
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          console.warn(`Key "${key}" not found in locale "${locale}"`);
+        }
+      } // Create the i18n chunk file
+
+      const moduleSource = `window.loadI18nChunk(${JSON.stringify(i18nData, null, 2)});`;
+      const filename = `i18n-chunks/${locale}/${cacheGroupName}.js`;
+      compilation.emitAsset(filename, new RawSource(moduleSource)); // Update the main manifest
+
+      if (!manifest.locales[locale]) {
+        manifest.locales[locale] = {};
+      }
+      manifest.locales[locale][cacheGroupName] = filename;
+    } // Update the cacheGroupToI18nMap
+
+    manifest.cacheGroupToI18nMap[cacheGroupName] = cacheGroupName;
+  } // Generate the meta manifest by converting Sets to Arrays
+
+  for (const [key, cacheGroupsSet] of Object.entries(keyToCacheGroupMap)) {
+    metaManifest.keyToCacheGroupMap[key] = Array.from(cacheGroupsSet);
+  } // Emit the main manifest file
+
+  const manifestSource = new RawSource(`window.i18n = window.i18n || {}; window.i18n.manifest = ${JSON.stringify(manifest, null, 2)};`);
+  const manifestFilename = 'i18n-chunk/manifest.js';
+  compilation.emitAsset(manifestFilename, manifestSource);
+  console.log(`Emitted i18n manifest: ${manifestFilename}`); // Emit the meta manifest file
+
+  const metaManifestSource = new RawSource(JSON.stringify(metaManifest, null, 2));
+  const metaManifestFilename = 'i18n-chunk/metaManifest.json';
+  compilation.emitAsset(metaManifestFilename, metaManifestSource);
+  console.log(`Emitted i18n meta manifest: ${metaManifestFilename}`);
+}
+module.exports = {
+  generateManifests
+};

package/lib/plugins/newi18nsplitplugin/UnicodeConversionPlugin.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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
+  };
+}
+
+// UnicodeConversionPlugin.js
+class UnicodeConversionPlugin {
+  constructor(options = {}) {
+    this.options = {
+      test: '',
+      // i18nPublicPath
+      encoding: 'utf8',
+      debug: false,
+      ...options
+    };
+  }
+  apply(compiler) {
+    // Run before the I18n plugin
+    compiler.hooks.beforeRun.tapAsync('UnicodeConversionPlugin', (compiler, callback) => {
+      try {
+        const targetPath = _path.default.resolve(compiler.context, this.options.test);
+        if (!_fs.default.existsSync(targetPath)) {
+          throw new Error(`Path not found: ${targetPath}`);
+        } // Convert files in place
+
+        this.convertFilesInPlace(targetPath);
+        callback();
+      } catch (err) {
+        callback(err);
+      }
+    });
+  }
+  convertFilesInPlace(targetPath) {
+    const processDir = dir => {
+      const files = _fs.default.readdirSync(dir);
+      files.forEach(file => {
+        const fullPath = _path.default.join(dir, file);
+        const stat = _fs.default.statSync(fullPath);
+        if (stat.isDirectory()) {
+          processDir(fullPath);
+        } else if (file.endsWith('.properties')) {
+          try {
+            // Read file
+            const content = _fs.default.readFileSync(fullPath, this.options.encoding); // Convert content
+
+            const convertedContent = this.convertUnicode(content); // Write back to same file
+
+            _fs.default.writeFileSync(fullPath, convertedContent, this.options.encoding);
+            if (this.options.debug) {
+              console.log(`[UnicodeConversionPlugin] Converted: ${_path.default.relative(targetPath, fullPath)}`);
+            }
+          } catch (error) {
+            console.error(`Error processing ${fullPath}: ${error.message}`);
+          }
+        }
+      });
+    };
+    processDir(targetPath);
+  }
+  convertUnicode(content) {
+    const lines = content.split(/\r?\n/);
+    const converted = lines.map(line => {
+      // Skip comments and empty lines
+      if (line.startsWith('#') || !line.trim()) {
+        return line;
+      } // Find key-value separator
+
+      const equalIndex = line.indexOf('=');
+      if (equalIndex === -1) {
+        return line;
+      }
+      const key = line.substring(0, equalIndex).trim();
+      const value = line.substring(equalIndex + 1).trim(); // Convert unicode escapes in the value
+
+      const convertedValue = this.convertUnicodeEscapes(value);
+      return `${key}=${convertedValue}`;
+    });
+    return converted.join('\n');
+  }
+  convertUnicodeEscapes(str) {
+    return str.replace(/\\u([0-9a-fA-F]{4})/g, (match, hex) => {
+      try {
+        return String.fromCharCode(parseInt(hex, 16));
+      } catch (err) {
+        throw new Error(`Invalid unicode escape sequence: ${match}`);
+      }
+    });
+  }
+}
+var _default = UnicodeConversionPlugin;
+exports.default = _default;

package/lib/plugins/newi18nsplitplugin/constants.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VALIDATION = exports.RUNTIME_CONFIG = exports.RETRY_STRATEGY = exports.PERFORMANCE = exports.MANIFEST_FIELDS = exports.LOADING_MODES = exports.FILE_PATTERNS = exports.FILE_DEFAULTS = exports.FEATURES = exports.ERROR_MESSAGES = exports.CHUNK_SIZE_LIMITS = exports.CHUNK_HINTS = exports.CACHE_CONFIG = exports.ALL_I18N_KEYS = void 0;
+// constants.js
+// Chunk size limits
+const CHUNK_SIZE_LIMITS = {
+  // Maximum keys in a single chunk (prevent >60% keys in one chunk)
+  MAX_CHUNK_SIZE: 200,
+  // Minimum keys before considering chunk merge
+  MIN_CHUNK_SIZE: 50,
+  // Ideal chunk size for optimal loading
+  IDEAL_CHUNK_SIZE: 100,
+  // Maximum percentage of total keys in one chunk
+  MAX_CHUNK_PERCENTAGE: 0.2,
+  // 20%
+  // Chunk size variance allowed before rebalancing
+  CHUNK_SIZE_VARIANCE: 0.2 // 20% variance allowed
+}; // Cache settings
+
+exports.CHUNK_SIZE_LIMITS = CHUNK_SIZE_LIMITS;
+const CACHE_CONFIG = {
+  // Maximum number of chunks to cache
+  MAX_CACHED_CHUNKS: 50,
+  // Maximum age of cached chunks (ms)
+  CACHE_TTL: 3600000,
+  // 1 hour
+  // Cache version for cache busting
+  CACHE_VERSION: '1.0.0'
+}; // File patterns
+
+exports.CACHE_CONFIG = CACHE_CONFIG;
+const FILE_PATTERNS = {
+  // JavaScript file extensions to scan
+  JS_EXTENSIONS: /\.(js|jsx|ts|tsx)$/,
+  // i18n key patterns to match
+  I18N_KEY_PATTERN: /^[a-zA-Z0-9_.-]+$/,
+  // Comment patterns for i18n keys
+  I18N_COMMENT_PATTERN: /^i18n:/
+}; // Loading modes
+
+exports.FILE_PATTERNS = FILE_PATTERNS;
+const LOADING_MODES = {
+  EAGER: 'eager',
+  // Load chunks immediately
+  LAZY: 'lazy',
+  // Load chunks on demand
+  PREFETCH: 'prefetch',
+  // Load chunks after main content
+  PRELOAD: 'preload' // Load chunks with high priority
+}; // Default file names and paths
+
+exports.LOADING_MODES = LOADING_MODES;
+const FILE_DEFAULTS = {
+  // Default manifest file name
+  MANIFEST_FILE: 'i18n-manifest.json',
+  // Fallback manifest file name
+  FALLBACK_MANIFEST_FILE: 'i18n-manifest.main.json',
+  // Stats file name
+  STATS_FILE: 'i18n-stats.json',
+  // Default chunk file pattern
+  CHUNK_FILENAME: 'i18n-chunk/[locale]/[name].[chunkhash].i18n.js'
+}; // Error messages
+
+exports.FILE_DEFAULTS = FILE_DEFAULTS;
+const ERROR_MESSAGES = {
+  NO_LOCALES: 'No locales specified in plugin options',
+  INVALID_KEY: 'Invalid i18n key format',
+  CHUNK_OVERFLOW: 'Chunk size exceeds maximum limit',
+  MANIFEST_ERROR: 'Failed to generate manifest',
+  LOAD_ERROR: 'Failed to load i18n chunk',
+  INVALID_CONFIG: 'Invalid plugin configuration'
+}; // Feature flags for experimental features
+
+exports.ERROR_MESSAGES = ERROR_MESSAGES;
+const FEATURES = {
+  ENABLE_KEY_MOVEMENT_TRACKING: true,
+  ENABLE_CHUNK_STATS: true,
+  ENABLE_SMART_LOADING: true,
+  ENABLE_CACHE_OPTIMIZATION: true,
+  ENABLE_DEBUG_LOGGING: false
+}; // Performance thresholds
+
+exports.FEATURES = FEATURES;
+const PERFORMANCE = {
+  // Maximum time to spend on chunk balancing (ms)
+  MAX_BALANCE_TIME: 1000,
+  // Maximum keys to process in one batch
+  BATCH_SIZE: 1000,
+  // Warning thresholds
+  WARNINGS: {
+    CHUNK_SIZE: 150,
+    // Warn when chunk exceeds this size
+    TOTAL_SIZE: 5000,
+    // Warn when total keys exceed this
+    LOAD_TIME: 500 // Warn when chunk load exceeds this (ms)
+  }
+}; // Runtime configurations that can be overridden
+
+exports.PERFORMANCE = PERFORMANCE;
+const RUNTIME_CONFIG = {
+  // Default timeout for chunk loading (ms)
+  CHUNK_TIMEOUT: 30000,
+  // Number of retry attempts for failed loads
+  MAX_RETRIES: 3,
+  // Delay between retries (ms)
+  RETRY_DELAY: 1000,
+  // Enable verbose logging
+  DEBUG_MODE: false
+}; // Manifest metadata fields
+
+exports.RUNTIME_CONFIG = RUNTIME_CONFIG;
+const MANIFEST_FIELDS = {
+  // Required fields in manifest
+  REQUIRED: ['version', 'generated', 'chunks', 'locales'],
+  // Optional metadata fields
+  METADATA: ['description', 'environment', 'buildId', 'commitHash']
+}; // Default retry strategy
+
+exports.MANIFEST_FIELDS = MANIFEST_FIELDS;
+const RETRY_STRATEGY = {
+  // Initial delay (ms)
+  initialDelay: 1000,
+  // Maximum delay (ms)
+  maxDelay: 10000,
+  // Backoff factor
+  factor: 2,
+  // Maximum number of retries
+  maxRetries: 3
+}; // Chunk optimization hints
+
+exports.RETRY_STRATEGY = RETRY_STRATEGY;
+const CHUNK_HINTS = {
+  // Threshold for splitting chunks
+  SPLIT_THRESHOLD: 0.8,
+  // 80% of max size
+  // Threshold for merging chunks
+  MERGE_THRESHOLD: 0.3,
+  // 30% of max size
+  // Preferred chunk size ranges
+  RANGES: {
+    SMALL: 50,
+    MEDIUM: 100,
+    LARGE: 150
+  }
+}; // Validation schemas (using simple pattern matching)
+
+exports.CHUNK_HINTS = CHUNK_HINTS;
+const VALIDATION = {
+  KEY_PATTERN: /^[a-zA-Z0-9_.]+$/,
+  LOCALE_PATTERN: /^[a-z]{2}(_[A-Z]{2})?$/,
+  CHUNK_NAME_PATTERN: /^[a-zA-Z0-9-_]+$/
+}; // Export all i18n keys for validation (this would be populated from your source)
+
+exports.VALIDATION = VALIDATION;
+const ALL_I18N_KEYS = new Set([
+// Example keys - in real implementation, these would be loaded from your source
+'common.ok', 'common.cancel', 'errors.notFound' // ... more keys
+]);
+exports.ALL_I18N_KEYS = ALL_I18N_KEYS;

package/lib/plugins/newi18nsplitplugin/utils/I18nKeyHasher.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const esprima = require('esprima');
+const crypto = require('crypto');
+class I18nKeyHasher {
+  constructor() {
+    this.keyHashMap = new Map();
+    this.hashKeyMap = new Map();
+    this.usedHashes = new Set();
+    this.hashLength = 5;
+  }
+  generateHash(key) {
+    const fullHash = crypto.createHash('md5').update(key).digest('hex');
+    let hash = fullHash.substring(0, this.hashLength);
+    let counter = 0;
+    let finalHash = hash;
+    while (this.usedHashes.has(finalHash)) {
+      counter++;
+      finalHash = hash + counter;
+    }
+    this.usedHashes.add(finalHash);
+    return finalHash;
+  }
+  hashKey(key) {
+    if (this.keyHashMap.has(key)) {
+      return this.keyHashMap.get(key);
+    }
+    const hash = this.generateHash(key);
+    this.keyHashMap.set(key, hash);
+    this.hashKeyMap.set(hash, key);
+    return hash;
+  }
+  replaceKeysInSource(sourceCode) {
+    try {
+      // Parse source using esprima
+      const ast = esprima.parse(sourceCode, {
+        range: true,
+        tokens: true,
+        comment: true,
+        jsx: true
+      }); // Track string literals to replace
+
+      const replacements = []; // Walk the AST to find string literals
+
+      const traverse = node => {
+        if (node.type === 'Literal' && typeof node.value === 'string' && this.keyHashMap.has(node.value)) {
+          replacements.push({
+            range: node.range,
+            value: this.keyHashMap.get(node.value)
+          });
+        } // Traverse child nodes
+
+        for (const key in node) {
+          if (node[key] && typeof node[key] === 'object') {
+            if (Array.isArray(node[key])) {
+              node[key].forEach(child => child && traverse(child));
+            } else {
+              traverse(node[key]);
+            }
+          }
+        }
+      };
+      traverse(ast); // Apply replacements in reverse order
+
+      replacements.sort((a, b) => b.range[0] - a.range[0]).forEach(({
+        range,
+        value
+      }) => {
+        sourceCode = sourceCode.slice(0, range[0]) + `"${value}"` + sourceCode.slice(range[1]);
+      });
+      return sourceCode;
+    } catch (err) {
+      console.warn('Error during source transformation:', err);
+      return sourceCode; // Return original source if transformation fails
+    }
+  }
+}
+module.exports = I18nKeyHasher;