@zohodesk/i18n 1.0.0-beta.37-murphy → 1.0.0-beta.38-murphy-logs

package/es/index.js

@@ -1,5 +1,5 @@
 export { formatDate, pad, replaceI18NValuesWithRegex, unescapeUnicode, getValues, getI18NInfo, isToday, isYesterday, isTomorrow, isWithinAWeek, isTwoWeeksOrMore, userDateFormat, getDiffObj, getLyears, getSuffix, getDatePatternWithoutYear, setLocalizedData, setI18NKeyMapping, dayi18n, monthi18n, timei18n } from "./utils";
-export { reportI18NError, clearReportedKeys, I18N_ERROR_TYPES } from "./utils/errorReporter";
+export { reportI18NError, flushI18NErrors, clearReportedKeys, I18N_ERROR_TYPES } from "./utils/errorReporter";
 import { getI18NValue as getI18NValue1 } from "./utils";
 export { I18NContext } from "./I18NContext";
 export { default as I18NProvider, i18NProviderUtils } from "./components/I18NProvider";

package/es/utils/errorReporter.js

@@ -4,30 +4,363 @@ export const I18N_ERROR_TYPES = {
   NUMERIC_FALLBACK: 'I18N_NUMERIC_FALLBACK'
 };
 const reportedKeys = new Set();
+const pendingErrors = new Map();
+const MAX_PENDING_ERRORS = 100;
+
+// STARTUP DIAGNOSTIC - Run once when module loads
+(function runStartupDiagnostic() {
+  console.log('╔═══════════════════════════════════════════════════════════╗');
+  console.log('║  i18n ERROR REPORTER - STARTUP DIAGNOSTIC                ║');
+  console.log('╚═══════════════════════════════════════════════════════════╝');
+  const diagnostic = {
+    moduleLoadTime: new Date().toISOString(),
+    environment: {
+      hasWindow: typeof window !== 'undefined',
+      windowLocation: typeof window !== 'undefined' ? window.location.href : 'no window',
+      isIframe: typeof window !== 'undefined' ? window.self !== window.top : 'unknown',
+      userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown'
+    },
+    murphy: {
+      exists: typeof murphy !== 'undefined',
+      hasErrorMethod: typeof murphy !== 'undefined' && typeof murphy.error === 'function',
+      type: typeof murphy,
+      methods: typeof murphy !== 'undefined' ? Object.keys(murphy) : 'murphy not defined'
+    },
+    zohoIM: {
+      exists: typeof window !== 'undefined' && typeof window.ZOHOIM !== 'undefined',
+      hasMurphyConfig: typeof window !== 'undefined' && typeof window.ZOHOIM !== 'undefined' && typeof window.ZOHOIM.murphyConfig !== 'undefined',
+      murphyConfig: typeof window !== 'undefined' && window.ZOHOIM ? window.ZOHOIM.murphyConfig : 'ZOHOIM not available'
+    },
+    state: {
+      reportedKeysCount: reportedKeys.size,
+      pendingErrorsCount: pendingErrors.size,
+      maxPendingErrors: MAX_PENDING_ERRORS
+    }
+  };
+  console.log('[i18n-debug] STARTUP DIAGNOSTIC:', diagnostic);
+  console.log('╚═══════════════════════════════════════════════════════════╝');
+})();
 function isMurphyAvailable() {
-  return typeof murphy !== 'undefined' && typeof murphy.error === 'function';
+  const available = typeof murphy !== 'undefined' && typeof murphy.error === 'function';
+
+  // COMPREHENSIVE MURPHY INSPECTION
+  const murphyDetails = {
+    murphyExists: typeof murphy !== 'undefined',
+    murphyErrorExists: typeof murphy !== 'undefined' && typeof murphy.error === 'function',
+    available,
+    murphyType: typeof murphy,
+    windowLocation: typeof window !== 'undefined' ? window.location.href : 'no window',
+    isIframe: typeof window !== 'undefined' ? window.self !== window.top : 'no window'
+  };
+  if (typeof murphy !== 'undefined') {
+    // Log all Murphy methods
+    murphyDetails.murphyMethods = Object.keys(murphy);
+
+    // Log Murphy config if accessible
+    if (typeof murphy.config === 'object') {
+      murphyDetails.murphyConfig = murphy.config;
+    }
+
+    // Log Murphy app info if accessible
+    if (typeof murphy.appKey !== 'undefined') {
+      murphyDetails.murphyAppKey = murphy.appKey;
+    }
+
+    // Try to get Murphy internal state
+    try {
+      murphyDetails.murphyState = {
+        installed: typeof murphy.installed !== 'undefined' ? murphy.installed : 'unknown',
+        version: typeof murphy.version !== 'undefined' ? murphy.version : 'unknown'
+      };
+    } catch (e) {
+      murphyDetails.murphyStateError = e.message;
+    }
+  }
+
+  // Log window.ZOHOIM Murphy config
+  if (typeof window !== 'undefined' && typeof window.ZOHOIM !== 'undefined') {
+    murphyDetails.windowZOHOIM = {
+      exists: true,
+      hasMurphyConfig: typeof window.ZOHOIM.murphyConfig !== 'undefined',
+      murphyConfig: window.ZOHOIM.murphyConfig
+    };
+  } else {
+    murphyDetails.windowZOHOIM = 'not available';
+  }
+  console.log('[i18n-debug] Murphy availability check:', murphyDetails);
+  return available;
+}
+function isDebugEnabled() {
+  return true; // ALWAYS ENABLED FOR DEBUGGING
+}
+function debugLog(message, meta) {
+  // ALWAYS LOG - debug flag removed
+  if (typeof console === 'undefined' || typeof console.log !== 'function') {
+    return;
+  }
+  if (typeof meta === 'undefined') {
+    console.log(`[i18n] ${message}`);
+  } else {
+    console.log(`[i18n] ${message}`, meta);
+  }
+}
+function sendToMurphy(type, key) {
+  debugLog('reporting i18n error', {
+    type,
+    key
+  });
+
+  // COMPREHENSIVE MURPHY STATE INSPECTION
+  const murphyInspection = {
+    murphyType: typeof murphy,
+    murphyErrorType: typeof murphy.error,
+    murphyMethods: typeof murphy === 'object' ? Object.keys(murphy) : 'not an object',
+    timestamp: new Date().toISOString(),
+    url: typeof window !== 'undefined' ? window.location.href : 'no window'
+  };
+
+  // Get Murphy internal config
+  if (typeof murphy !== 'undefined') {
+    try {
+      murphyInspection.murphyInternalConfig = {
+        config: murphy.config || 'no config property',
+        appKey: murphy.appKey || 'no appKey property',
+        authKey: murphy.authKey || 'no authKey property',
+        appDomain: murphy.appDomain || 'no appDomain property',
+        endpoint: murphy.endpoint || 'no endpoint property',
+        url: murphy.url || 'no url property'
+      };
+    } catch (e) {
+      murphyInspection.murphyConfigError = e.message;
+    }
+  }
+
+  // Get window.ZOHOIM config
+  if (typeof window !== 'undefined' && typeof window.ZOHOIM !== 'undefined') {
+    murphyInspection.windowZOHOIM = {
+      exists: true,
+      murphyConfig: window.ZOHOIM.murphyConfig || 'no murphyConfig',
+      getUserInfo: typeof window.ZOHOIM.getUserInfo === 'function' ? window.ZOHOIM.getUserInfo() : 'no getUserInfo',
+      getServiceOrgInfo: typeof window.ZOHOIM.getServiceOrgInfo === 'function' ? window.ZOHOIM.getServiceOrgInfo() : 'no getServiceOrgInfo'
+    };
+  }
+
+  // Get global murphy config if available
+  if (typeof window !== 'undefined' && typeof window.murphyConfig !== 'undefined') {
+    murphyInspection.globalMurphyConfig = window.murphyConfig;
+  }
+  console.log('[i18n-debug] ═══════════════════════════════════════════');
+  console.log('[i18n-debug] MURPHY STATE BEFORE ERROR CALL:');
+  console.log('[i18n-debug]', murphyInspection);
+  console.log('[i18n-debug] ═══════════════════════════════════════════');
+  const error = new Error(`i18n ${type}: ${key}`);
+  error.name = type;
+  const murphyOptions = {
+    customTags: {
+      errorType: type,
+      i18nKey: key,
+      category: 'i18n'
+    },
+    preventClientGrouping: true
+  };
+  console.log('[i18n-debug] murphy.error() CALL PARAMETERS:', {
+    errorMessage: error.message,
+    errorName: error.name,
+    errorStack: error.stack,
+    options: murphyOptions,
+    timestamp: new Date().toISOString()
+  });
+
+  // Intercept network requests to see Murphy API calls
+  const originalFetch = typeof window !== 'undefined' ? window.fetch : null;
+  const originalXHR = typeof window !== 'undefined' ? window.XMLHttpRequest : null;
+  let networkCallDetected = false;
+
+  // Monitor fetch calls
+  if (originalFetch && typeof window !== 'undefined') {
+    window.fetch = function (...args) {
+      console.log('[i18n-debug] 🌐 FETCH CALL DETECTED (possibly from Murphy):', {
+        url: args[0],
+        options: args[1],
+        timestamp: new Date().toISOString()
+      });
+      networkCallDetected = true;
+      return originalFetch.apply(this, args);
+    };
+  }
+  try {
+    console.log('[i18n-debug] ▶ CALLING murphy.error() NOW...');
+    const result = murphy.error(error, undefined, murphyOptions);
+    console.log('[i18n-debug] ✅ murphy.error() COMPLETED:', {
+      result,
+      resultType: typeof result,
+      success: true,
+      networkCallDetected,
+      timestamp: new Date().toISOString()
+    });
+
+    // Check if Murphy queued the error
+    if (typeof murphy.getQueuedErrors === 'function') {
+      console.log('[i18n-debug] Murphy queued errors:', murphy.getQueuedErrors());
+    }
+  } catch (err) {
+    console.error('[i18n-debug] ❌ murphy.error() FAILED:', {
+      error: err.message,
+      stack: err.stack,
+      timestamp: new Date().toISOString()
+    });
+  } finally {
+    // Restore original fetch
+    if (originalFetch && typeof window !== 'undefined') {
+      setTimeout(() => {
+        window.fetch = originalFetch;
+        console.log('[i18n-debug] Network call detected:', networkCallDetected);
+      }, 100);
+    }
+  }
+  console.log('[i18n-debug] ═══════════════════════════════════════════');
+}
+function queuePendingError(dedupeKey, type, key) {
+  if (pendingErrors.has(dedupeKey)) {
+    debugLog('pending i18n error deduped', {
+      type,
+      key
+    });
+    return;
+  }
+  if (pendingErrors.size >= MAX_PENDING_ERRORS) {
+    const oldestKey = pendingErrors.keys().next().value;
+    pendingErrors.delete(oldestKey);
+    debugLog('pending i18n error dropped (queue full)', {
+      droppedKey: oldestKey,
+      pendingSize: pendingErrors.size
+    });
+  }
+  pendingErrors.set(dedupeKey, {
+    type,
+    key
+  });
+  debugLog('queued i18n error (murphy not ready)', {
+    type,
+    key,
+    pendingSize: pendingErrors.size
+  });
+}
+export function flushI18NErrors() {
+  console.log('[i18n-debug] flushI18NErrors ENTRY:', {
+    pendingErrorsSize: pendingErrors.size,
+    pendingErrors: Array.from(pendingErrors.entries()),
+    reportedKeysSize: reportedKeys.size
+  });
+  if (!isMurphyAvailable()) {
+    debugLog('flush skipped (murphy not available)', {
+      pendingSize: pendingErrors.size
+    });
+    console.log('[i18n-debug] Flush SKIPPED - Murphy not available');
+    return;
+  }
+  if (pendingErrors.size === 0) {
+    debugLog('flush skipped (no pending errors)');
+    console.log('[i18n-debug] Flush SKIPPED - No pending errors');
+    return;
+  }
+  debugLog('flushing pending i18n errors', {
+    pendingSize: pendingErrors.size
+  });
+  console.log('[i18n-debug] FLUSHING pending errors:', {
+    count: pendingErrors.size,
+    errors: Array.from(pendingErrors.entries())
+  });
+  let flushedCount = 0;
+  for (const [dedupeKey, data] of pendingErrors) {
+    console.log('[i18n-debug] Processing pending error:', {
+      dedupeKey,
+      data,
+      alreadyReported: reportedKeys.has(dedupeKey)
+    });
+    if (reportedKeys.has(dedupeKey)) {
+      console.log('[i18n-debug] Skipping already reported key:', dedupeKey);
+      pendingErrors.delete(dedupeKey);
+      continue;
+    }
+    console.log('[i18n-debug] Sending pending error to Murphy:', dedupeKey);
+    sendToMurphy(data.type, data.key);
+    reportedKeys.add(dedupeKey);
+    pendingErrors.delete(dedupeKey);
+    flushedCount += 1;
+  }
+  debugLog('flush complete', {
+    flushedCount,
+    pendingRemaining: pendingErrors.size
+  });
+  console.log('[i18n-debug] Flush COMPLETE:', {
+    flushedCount,
+    pendingRemaining: pendingErrors.size,
+    reportedKeysSize: reportedKeys.size
+  });
 }
 export function reportI18NError(type, key) {
+  debugLog('reportI18NError called', {
+    type,
+    key
+  });
+  console.log('[i18n-debug] reportI18NError ENTRY:', {
+    type,
+    key,
+    url: typeof window !== 'undefined' ? window.location.href : 'no window',
+    timestamp: new Date().toISOString(),
+    reportedKeysSize: reportedKeys.size,
+    reportedKeys: Array.from(reportedKeys),
+    pendingErrorsSize: pendingErrors.size
+  });
   const dedupeKey = `${type}:${key}`;
+  console.log('[i18n-debug] Deduplication check:', {
+    dedupeKey,
+    alreadyReported: reportedKeys.has(dedupeKey),
+    reportedKeysSet: Array.from(reportedKeys)
+  });
   if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped', {
+      type,
+      key
+    });
+    console.log('[i18n-debug] DEDUPED - EXITING reportI18NError');
     return;
   }
-  reportedKeys.add(dedupeKey);
-  if (isMurphyAvailable()) {
-    const error = new Error(`i18n ${type}: ${key}`);
-    error.name = type;
-    murphy.error(error, undefined, {
-      customTags: {
-        errorType: type,
-        i18nKey: key,
-        category: 'i18n'
-      },
-      preventClientGrouping: true
+  console.log('[i18n-debug] NOT deduped, proceeding with Murphy check');
+  if (!isMurphyAvailable()) {
+    debugLog('murphy not available, queueing i18n error', {
+      type,
+      key
     });
+    console.log('[i18n-debug] Murphy NOT available, queueing error');
+    queuePendingError(dedupeKey, type, key);
+    return;
   }
+  console.log('[i18n-debug] Murphy IS available, flushing pending errors');
+  flushI18NErrors();
+  console.log('[i18n-debug] Post-flush deduplication check:', {
+    dedupeKey,
+    alreadyReported: reportedKeys.has(dedupeKey),
+    reportedKeysSet: Array.from(reportedKeys)
+  });
+  if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped after flush', {
+      type,
+      key
+    });
+    console.log('[i18n-debug] DEDUPED AFTER FLUSH - EXITING reportI18NError');
+    return;
+  }
+  console.log('[i18n-debug] About to call sendToMurphy');
+  sendToMurphy(type, key);
+  reportedKeys.add(dedupeKey);
+  console.log('[i18n-debug] Added to reportedKeys, new size:', reportedKeys.size);
 }
 export function clearReportedKeys() {
   reportedKeys.clear();
+  pendingErrors.clear();
+  debugLog('cleared reported and pending i18n errors');
 }
 export function getFallbackText(key) {
   const isNumeric = /^\d+$/.test(key);

package/es/utils/index.js

@@ -234,17 +234,47 @@ export function getLocalizedValue({
   return localizedValue || null;
 }
 export function getI18NValue(i18n) {
+  console.log('[i18n-debug] getI18NValue called:', {
+    i18nType: typeof i18n,
+    i18nIsDefined: typeof i18n !== 'undefined',
+    i18nKeysCount: typeof i18n === 'object' ? Object.keys(i18n).length : 0,
+    url: typeof window !== 'undefined' ? window.location.href : 'no window'
+  });
   if (typeof i18n === 'undefined') {
+    console.error('[i18n-debug] i18n object is UNDEFINED! Reporting error and returning fallback');
     reportI18NError(I18N_ERROR_TYPES.UNDEFINED_OBJECT, 'i18n_object');
     return key => key;
   }
   return (key, values, localizedProps) => {
+    console.log('[i18n-debug] getI18NValue lookup:', {
+      key,
+      values,
+      localizedProps,
+      mappedKey: getMappedKey(key),
+      hasLocalizedValue: localizedProps ? !!getLocalizedValue(localizedProps) : !!localizedStringData[key]
+    });
     const localizedValue = localizedProps ? getLocalizedValue(localizedProps) : localizedStringData[key];
     const finalKey = getMappedKey(key);
     let i18nStr = i18n[finalKey];
+    console.log('[i18n-debug] i18n lookup result:', {
+      originalKey: key,
+      finalKey,
+      found: i18nStr !== undefined,
+      i18nStrValue: i18nStr,
+      willFallback: i18nStr === undefined
+    });
     if (i18nStr === undefined) {
       const isNumeric = /^\d+$/.test(finalKey);
-      reportI18NError(isNumeric ? I18N_ERROR_TYPES.NUMERIC_FALLBACK : I18N_ERROR_TYPES.MISSING_KEY, finalKey);
+      const errorType = isNumeric ? I18N_ERROR_TYPES.NUMERIC_FALLBACK : I18N_ERROR_TYPES.MISSING_KEY;
+      console.warn('[i18n-debug] MISSING KEY detected!', {
+        finalKey,
+        isNumeric,
+        errorType,
+        fallbackText: getFallbackText(finalKey),
+        aboutToCallReportI18NError: true,
+        timestamp: new Date().toISOString()
+      });
+      reportI18NError(errorType, finalKey);
       return localizedValue || getFallbackText(finalKey);
     }
     i18nStr = replaceI18NValuesWithRegex(i18nStr, values);

package/lib/index.js

@@ -70,6 +70,12 @@ Object.defineProperty(exports, "dayi18n", {
     return _utils.dayi18n;
   }
 });
+Object.defineProperty(exports, "flushI18NErrors", {
+  enumerable: true,
+  get: function get() {
+    return _errorReporter.flushI18NErrors;
+  }
+});
 Object.defineProperty(exports, "formatDate", {
   enumerable: true,
   get: function get() {