@zohodesk/i18n 1.0.0-beta.36-murphy → 1.0.0-beta.38-murphy

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,135 @@ export const I18N_ERROR_TYPES = {
   NUMERIC_FALLBACK: 'I18N_NUMERIC_FALLBACK'
 };
 const reportedKeys = new Set();
+const pendingErrors = new Map();
+const MAX_PENDING_ERRORS = 100;
 function isMurphyAvailable() {
   return typeof murphy !== 'undefined' && typeof murphy.error === 'function';
 }
+function isDebugEnabled() {
+  return typeof window !== 'undefined' && window.__I18N_DEBUG__ === true;
+}
+function debugLog(message, meta) {
+  if (!isDebugEnabled() || typeof console === 'undefined') {
+    return;
+  }
+  if (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
+  });
+  const error = new Error(`i18n ${type}: ${key}`);
+  error.name = type;
+  murphy.error(error, undefined, {
+    customTags: {
+      errorType: type,
+      i18nKey: key,
+      category: 'i18n'
+    },
+    preventClientGrouping: true
+  });
+}
+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() {
+  if (!isMurphyAvailable()) {
+    debugLog('flush skipped (murphy not available)', {
+      pendingSize: pendingErrors.size
+    });
+    return;
+  }
+  if (pendingErrors.size === 0) {
+    debugLog('flush skipped (no pending errors)');
+    return;
+  }
+  debugLog('flushing pending i18n errors', {
+    pendingSize: pendingErrors.size
+  });
+  let flushedCount = 0;
+  for (const [dedupeKey, data] of pendingErrors) {
+    if (reportedKeys.has(dedupeKey)) {
+      pendingErrors.delete(dedupeKey);
+      continue;
+    }
+    sendToMurphy(data.type, data.key);
+    reportedKeys.add(dedupeKey);
+    pendingErrors.delete(dedupeKey);
+    flushedCount += 1;
+  }
+  debugLog('flush complete', {
+    flushedCount,
+    pendingRemaining: pendingErrors.size
+  });
+}
 export function reportI18NError(type, key) {
+  debugLog('reportI18NError called', {
+    type,
+    key
+  });
   const dedupeKey = `${type}:${key}`;
   if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped', {
+      type,
+      key
+    });
     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
+  if (!isMurphyAvailable()) {
+    debugLog('murphy not available, queueing i18n error', {
+      type,
+      key
     });
+    queuePendingError(dedupeKey, type, key);
+    return;
   }
+  flushI18NErrors();
+  if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped after flush', {
+      type,
+      key
+    });
+    return;
+  }
+  sendToMurphy(type, key);
+  reportedKeys.add(dedupeKey);
 }
 export function clearReportedKeys() {
   reportedKeys.clear();
+  pendingErrors.clear();
+  debugLog('cleared reported and pending i18n errors');
 }
 export function getFallbackText(key) {
   const isNumeric = /^\d+$/.test(key);

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() {

package/lib/utils/errorReporter.js

@@ -5,38 +5,162 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.I18N_ERROR_TYPES = void 0;
 exports.clearReportedKeys = clearReportedKeys;
+exports.flushI18NErrors = flushI18NErrors;
 exports.getFallbackText = getFallbackText;
 exports.reportI18NError = reportI18NError;
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 var I18N_ERROR_TYPES = exports.I18N_ERROR_TYPES = {
   UNDEFINED_OBJECT: 'I18N_UNDEFINED_OBJECT',
   MISSING_KEY: 'I18N_MISSING_KEY',
   NUMERIC_FALLBACK: 'I18N_NUMERIC_FALLBACK'
 };
 var reportedKeys = new Set();
+var pendingErrors = new Map();
+var MAX_PENDING_ERRORS = 100;
 function isMurphyAvailable() {
   return typeof murphy !== 'undefined' && typeof murphy.error === 'function';
 }
+function isDebugEnabled() {
+  return typeof window !== 'undefined' && window.__I18N_DEBUG__ === true;
+}
+function debugLog(message, meta) {
+  if (!isDebugEnabled() || typeof console === 'undefined') {
+    return;
+  }
+  if (typeof console.log !== 'function') {
+    return;
+  }
+  if (typeof meta === 'undefined') {
+    console.log("[i18n] ".concat(message));
+  } else {
+    console.log("[i18n] ".concat(message), meta);
+  }
+}
+function sendToMurphy(type, key) {
+  debugLog('reporting i18n error', {
+    type: type,
+    key: key
+  });
+  var error = new Error("i18n ".concat(type, ": ").concat(key));
+  error.name = type;
+  murphy.error(error, undefined, {
+    customTags: {
+      errorType: type,
+      i18nKey: key,
+      category: 'i18n'
+    },
+    preventClientGrouping: true
+  });
+}
+function queuePendingError(dedupeKey, type, key) {
+  if (pendingErrors.has(dedupeKey)) {
+    debugLog('pending i18n error deduped', {
+      type: type,
+      key: key
+    });
+    return;
+  }
+  if (pendingErrors.size >= MAX_PENDING_ERRORS) {
+    var oldestKey = pendingErrors.keys().next().value;
+    pendingErrors["delete"](oldestKey);
+    debugLog('pending i18n error dropped (queue full)', {
+      droppedKey: oldestKey,
+      pendingSize: pendingErrors.size
+    });
+  }
+  pendingErrors.set(dedupeKey, {
+    type: type,
+    key: key
+  });
+  debugLog('queued i18n error (murphy not ready)', {
+    type: type,
+    key: key,
+    pendingSize: pendingErrors.size
+  });
+}
+function flushI18NErrors() {
+  if (!isMurphyAvailable()) {
+    debugLog('flush skipped (murphy not available)', {
+      pendingSize: pendingErrors.size
+    });
+    return;
+  }
+  if (pendingErrors.size === 0) {
+    debugLog('flush skipped (no pending errors)');
+    return;
+  }
+  debugLog('flushing pending i18n errors', {
+    pendingSize: pendingErrors.size
+  });
+  var flushedCount = 0;
+  var _iterator = _createForOfIteratorHelper(pendingErrors),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        dedupeKey = _step$value[0],
+        data = _step$value[1];
+      if (reportedKeys.has(dedupeKey)) {
+        pendingErrors["delete"](dedupeKey);
+        continue;
+      }
+      sendToMurphy(data.type, data.key);
+      reportedKeys.add(dedupeKey);
+      pendingErrors["delete"](dedupeKey);
+      flushedCount += 1;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  debugLog('flush complete', {
+    flushedCount: flushedCount,
+    pendingRemaining: pendingErrors.size
+  });
+}
 function reportI18NError(type, key) {
+  debugLog('reportI18NError called', {
+    type: type,
+    key: key
+  });
   var dedupeKey = "".concat(type, ":").concat(key);
   if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped', {
+      type: type,
+      key: key
+    });
     return;
   }
-  reportedKeys.add(dedupeKey);
-  if (isMurphyAvailable()) {
-    var error = new Error("i18n ".concat(type, ": ").concat(key));
-    error.name = type;
-    murphy.error(error, undefined, {
-      customTags: {
-        errorType: type,
-        i18nKey: key,
-        category: 'i18n'
-      },
-      preventClientGrouping: true
+  if (!isMurphyAvailable()) {
+    debugLog('murphy not available, queueing i18n error', {
+      type: type,
+      key: key
     });
+    queuePendingError(dedupeKey, type, key);
+    return;
   }
+  flushI18NErrors();
+  if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped after flush', {
+      type: type,
+      key: key
+    });
+    return;
+  }
+  sendToMurphy(type, key);
+  reportedKeys.add(dedupeKey);
 }
 function clearReportedKeys() {
   reportedKeys.clear();
+  pendingErrors.clear();
+  debugLog('cleared reported and pending i18n errors');
 }
 function getFallbackText(key) {
   var isNumeric = /^\d+$/.test(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/i18n",
-  "version": "1.0.0-beta.36-murphy",
+  "version": "1.0.0-beta.38-murphy",
   "main": "lib/index",
   "module": "es/index.js",
   "jsnext:main": "es/index.js",

package/src/index.js

@@ -23,6 +23,7 @@ export {
 } from './utils';
 export {
   reportI18NError,
+  flushI18NErrors,
   clearReportedKeys,
   I18N_ERROR_TYPES
 } from './utils/errorReporter';

package/src/utils/errorReporter.js

@@ -5,34 +5,131 @@ export const I18N_ERROR_TYPES = {
 };
 
 const reportedKeys = new Set();
+const pendingErrors = new Map();
+const MAX_PENDING_ERRORS = 100;
 
 function isMurphyAvailable() {
   return typeof murphy !== 'undefined' && typeof murphy.error === 'function';
 }
 
+function isDebugEnabled() {
+  return typeof window !== 'undefined' && window.__I18N_DEBUG__ === true;
+}
+
+function debugLog(message, meta) {
+  if (!isDebugEnabled() || typeof console === 'undefined') {
+    return;
+  }
+  if (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 });
+  const error = new Error(`i18n ${type}: ${key}`);
+  error.name = type;
+
+  murphy.error(error, undefined, {
+    customTags: {
+      errorType: type,
+      i18nKey: key,
+      category: 'i18n'
+    },
+    preventClientGrouping: true
+  });
+}
+
+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() {
+  if (!isMurphyAvailable()) {
+    debugLog('flush skipped (murphy not available)', {
+      pendingSize: pendingErrors.size
+    });
+    return;
+  }
+
+  if (pendingErrors.size === 0) {
+    debugLog('flush skipped (no pending errors)');
+    return;
+  }
+
+  debugLog('flushing pending i18n errors', {
+    pendingSize: pendingErrors.size
+  });
+
+  let flushedCount = 0;
+  for (const [dedupeKey, data] of pendingErrors) {
+    if (reportedKeys.has(dedupeKey)) {
+      pendingErrors.delete(dedupeKey);
+      continue;
+    }
+    sendToMurphy(data.type, data.key);
+    reportedKeys.add(dedupeKey);
+    pendingErrors.delete(dedupeKey);
+    flushedCount += 1;
+  }
+
+  debugLog('flush complete', {
+    flushedCount,
+    pendingRemaining: pendingErrors.size
+  });
+}
+
 export function reportI18NError(type, key) {
+  debugLog('reportI18NError called', { type, key });
   const dedupeKey = `${type}:${key}`;
   if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped', { type, key });
     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
-    });
+  if (!isMurphyAvailable()) {
+    debugLog('murphy not available, queueing i18n error', { type, key });
+    queuePendingError(dedupeKey, type, key);
+    return;
+  }
+
+  flushI18NErrors();
+  if (reportedKeys.has(dedupeKey)) {
+    debugLog('reported i18n error deduped after flush', { type, key });
+    return;
   }
+
+  sendToMurphy(type, key);
+  reportedKeys.add(dedupeKey);
 }
 export function clearReportedKeys() {
   reportedKeys.clear();
+  pendingErrors.clear();
+  debugLog('cleared reported and pending i18n errors');
 }
 
 export function getFallbackText(key) {