@compilacion/colleciones-clientos 2.0.28 → 2.0.30

package/dist/browser.domainModel.gtm.config.sandbox.js

@@ -10,12 +10,13 @@ var collecionesClientosGtmConfigSandbox = (function (exports) {
             'trackerName': 'trackerName',
             'appName': 'appName',
             'emitterEndpoint': 'emitterEndpoint',
+            'errorLoggingEndpoint': 'errorLoggingEndpoint',
             'typeName': 'type'
         },
         'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'
     };
 
-    function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput) {    
+    function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput, errorLoggingEndpoint) {
         let returnObject = {};
         returnObject[constants.config.typeName] = constants.typeCastGtmVariableConfig;
         returnObject[constants.config.emitterEndpoint] = endpoint;
@@ -25,9 +26,12 @@ var collecionesClientosGtmConfigSandbox = (function (exports) {
         returnObject[constants.config.appName] = appName;
         returnObject[constants.config.sourceName] = jsLibSource;
         returnObject[constants.config.jsLibUrlVariable] = jsLibUrlInput;
+        // Optional: providing the URL of the server-side error-logging endpoint is what
+        // turns frontend error forwarding on. When left empty the runtime stays silent.
+        returnObject[constants.config.errorLoggingEndpoint] = errorLoggingEndpoint;
         return returnObject;
     }
-    /* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl);*/
+    /* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl, errorLoggingEndpoint);*/
 
     exports.getConfigObject = getConfigObject;
 

package/dist/browser.domainModel.gtm.config.sandbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"browser.domainModel.gtm.config.sandbox.js","sources":["../src/browser.domainModel.gtm.constants.js","../src/browser.domainModel.gtm.config.sandbox.js"],"sourcesContent":["var constants = {\n    'sharedWindowObjectNames': {\n        'queue': 'compilacionCollecionesClientosGtmQueue',\n        'configVariable': 'compilacionCollecionesClientosGtmTypeCastConfig'\n    },\n    'config': {\n        'sourceName': 'jsLibSource',\n        'jsLibUrlVariable': 'jsLibSource_selfHostedUrl',\n        'selfHostedValue': 'SELF',\n        'unpkgHostedValue': 'UNPKG',\n        'flushInterval': 'flushInterval',\n        'flushSize': 'flushSize',\n        'trackerName': 'trackerName',\n        'appName': 'appName',\n        'emitterEndpoint': 'emitterEndpoint',\n        'typeName': 'type'\n    },\n    'collecionesObject': 'compilacionCollecionesClientosGtm',\n    'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'\n};\n\nexport default constants;","import constants from './browser.domainModel.gtm.constants.js';\n\nexport function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput) {    \n    let jsLibUrl = null;\n    if(jsLibSource === constants.config.unpkgHostedValue) {\n        jsLibUrl = \"https://unpkg.com/@compilacion/colleciones-clientos@latest/dist/browser.gtm.min.js\";\n    } else if (jsLibSource === constants.config.selfHostedValue) {\n        jsLibUrl = jsLibUrlInput\n    }\n    let returnObject = {};\n    returnObject[constants.config.typeName] = constants.typeCastGtmVariableConfig;\n    returnObject[constants.config.emitterEndpoint] = endpoint;\n    returnObject[constants.config.flushInterval] = flushInterval;\n    returnObject[constants.config.flushSize] = flushSize;\n    returnObject[constants.config.trackerName] = trackerName;\n    returnObject[constants.config.appName] = appName;\n    returnObject[constants.config.sourceName] = jsLibSource;\n    returnObject[constants.config.jsLibUrlVariable] = jsLibUrlInput;\n    return returnObject;\n}\n/* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl);*/"],"names":[],"mappings":";;;IAAA,IAAI,SAAS,GAAG;IAChB,IAII,QAAQ,EAAE;IACd,QAAQ,YAAY,EAAE,aAAa;IACnC,QAAQ,kBAAkB,EAAE,2BAA2B;IACvD,QAEQ,eAAe,EAAE,eAAe;IACxC,QAAQ,WAAW,EAAE,WAAW;IAChC,QAAQ,aAAa,EAAE,aAAa;IACpC,QAAQ,SAAS,EAAE,SAAS;IAC5B,QAAQ,iBAAiB,EAAE,iBAAiB;IAC5C,QAAQ,UAAU,EAAE;IACpB,KAAK;IACL,IACI,2BAA2B,EAAE;IACjC,CAAC;;ICjBM,SAAS,eAAe,CAAC,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE;IAOtH,IAAI,IAAI,YAAY,GAAG,EAAE;IACzB,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,yBAAyB;IACjF,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,QAAQ;IAC7D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,aAAa;IAChE,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,SAAS;IACxD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,WAAW;IAC5D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,OAAO;IACpD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,WAAW;IAC3D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,aAAa;IACnE,IAAI,OAAO,YAAY;IACvB;IACA;;;;;;;;;;"}
+{"version":3,"file":"browser.domainModel.gtm.config.sandbox.js","sources":["../src/browser.domainModel.gtm.constants.js","../src/browser.domainModel.gtm.config.sandbox.js"],"sourcesContent":["var constants = {\n    'sharedWindowObjectNames': {\n        'queue': 'compilacionCollecionesClientosGtmQueue',\n        'configVariable': 'compilacionCollecionesClientosGtmTypeCastConfig'\n    },\n    'config': {\n        'sourceName': 'jsLibSource',\n        'jsLibUrlVariable': 'jsLibSource_selfHostedUrl',\n        'selfHostedValue': 'SELF',\n        'unpkgHostedValue': 'UNPKG',\n        'flushInterval': 'flushInterval',\n        'flushSize': 'flushSize',\n        'trackerName': 'trackerName',\n        'appName': 'appName',\n        'emitterEndpoint': 'emitterEndpoint',\n        'errorLoggingEndpoint': 'errorLoggingEndpoint',\n        'typeName': 'type'\n    },\n    'collecionesObject': 'compilacionCollecionesClientosGtm',\n    'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'\n};\n\nexport default constants;","import constants from './browser.domainModel.gtm.constants.js';\n\nexport function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput, errorLoggingEndpoint) {\n    let jsLibUrl = null;\n    if(jsLibSource === constants.config.unpkgHostedValue) {\n        jsLibUrl = \"https://unpkg.com/@compilacion/colleciones-clientos@latest/dist/browser.gtm.min.js\";\n    } else if (jsLibSource === constants.config.selfHostedValue) {\n        jsLibUrl = jsLibUrlInput\n    }\n    let returnObject = {};\n    returnObject[constants.config.typeName] = constants.typeCastGtmVariableConfig;\n    returnObject[constants.config.emitterEndpoint] = endpoint;\n    returnObject[constants.config.flushInterval] = flushInterval;\n    returnObject[constants.config.flushSize] = flushSize;\n    returnObject[constants.config.trackerName] = trackerName;\n    returnObject[constants.config.appName] = appName;\n    returnObject[constants.config.sourceName] = jsLibSource;\n    returnObject[constants.config.jsLibUrlVariable] = jsLibUrlInput;\n    // Optional: providing the URL of the server-side error-logging endpoint is what\n    // turns frontend error forwarding on. When left empty the runtime stays silent.\n    returnObject[constants.config.errorLoggingEndpoint] = errorLoggingEndpoint;\n    return returnObject;\n}\n/* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl, errorLoggingEndpoint);*/"],"names":[],"mappings":";;;IAAA,IAAI,SAAS,GAAG;IAChB,IAII,QAAQ,EAAE;IACd,QAAQ,YAAY,EAAE,aAAa;IACnC,QAAQ,kBAAkB,EAAE,2BAA2B;IACvD,QAEQ,eAAe,EAAE,eAAe;IACxC,QAAQ,WAAW,EAAE,WAAW;IAChC,QAAQ,aAAa,EAAE,aAAa;IACpC,QAAQ,SAAS,EAAE,SAAS;IAC5B,QAAQ,iBAAiB,EAAE,iBAAiB;IAC5C,QAAQ,sBAAsB,EAAE,sBAAsB;IACtD,QAAQ,UAAU,EAAE;IACpB,KAAK;IACL,IACI,2BAA2B,EAAE;IACjC,CAAC;;IClBM,SAAS,eAAe,CAAC,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,oBAAoB,EAAE;IAO5I,IAAI,IAAI,YAAY,GAAG,EAAE;IACzB,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,yBAAyB;IACjF,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,QAAQ;IAC7D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,aAAa;IAChE,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,SAAS;IACxD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,WAAW;IAC5D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,OAAO;IACpD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,WAAW;IAC3D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,aAAa;IACnE;IACA;IACA,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,oBAAoB,CAAC,GAAG,oBAAoB;IAC9E,IAAI,OAAO,YAAY;IACvB;IACA;;;;;;;;;;"}

package/dist/browser.domainModel.gtm.js

@@ -791,7 +791,8 @@
           'flushSize': 'flushSize',
           'trackerName': 'trackerName',
           'appName': 'appName',
-          'emitterEndpoint': 'emitterEndpoint'},
+          'emitterEndpoint': 'emitterEndpoint',
+          'errorLoggingEndpoint': 'errorLoggingEndpoint'},
       'collecionesObject': 'compilacionCollecionesClientosGtm',
       'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'
   };
@@ -808,6 +809,62 @@
           let queueReference = null;
           let processedQueueLength = 0;
 
+          // Identity/destination details captured from the GTM config so a caught error
+          // can be attributed (tracker/app) and forwarded to the right endpoint.
+          let appName = null;
+          let trackerName = null;
+          let errorLoggingEndpoint = null;
+
+          const safeStringify = (value) => {
+              if (value === undefined) return '';
+              if (typeof value === 'string') return value;
+              try {
+                  return JSON.stringify(value);
+              } catch (e) {
+                  return String(value);
+              }
+          };
+
+          // Forward a caught client-side error to the configured bad-event endpoint.
+          // The whole point of this is to make the try/catch fallbacks visible server-side,
+          // so it is strictly best-effort and must NEVER throw: a failure to report an
+          // error can not be allowed to break the tracking flow it is meant to protect.
+          // Reporting only happens when an errorLoggingEndpoint URL is configured.
+          const reportError = (error, details = {}) => {
+              if (!errorLoggingEndpoint) return;
+              if (typeof fetch !== 'function') return;
+              try {
+                  const payload = {
+                      errorName: (error && error.name) ? String(error.name) : 'Error',
+                      errorMessage: (error && error.message) ? String(error.message) : String(error),
+                      tracker: trackerName != null ? String(trackerName) : '',
+                      appName: appName != null ? String(appName) : '',
+                      entity: details.entity != null ? String(details.entity) : '',
+                      action: details.action != null ? String(details.action) : '',
+                      rawEvent: safeStringify(details.rawEvent),
+                      context: {
+                          // phase identifies which fallback caught the error: init, flush or group.
+                          phase: details.phase || '',
+                          stack: (error && error.stack) ? String(error.stack) : '',
+                          url: (typeof window !== 'undefined' && window.location) ? window.location.href : '',
+                          userAgent: (typeof navigator !== 'undefined' && navigator.userAgent) ? navigator.userAgent : '',
+                          language: (typeof navigator !== 'undefined' && navigator.language) ? navigator.language : '',
+                          clientTimestamp: new Date().toISOString()
+                      }
+                  };
+                  // keepalive lets a report fired during page unload still have a chance to land.
+                  fetch(errorLoggingEndpoint, {
+                      method: 'POST',
+                      credentials: 'include',
+                      keepalive: true,
+                      headers: { 'Content-Type': 'application/json' },
+                      body: JSON.stringify(payload)
+                  }).catch(() => {});
+              } catch (e) {
+                  // Swallow: error reporting can never be allowed to surface its own exception.
+              }
+          };
+
           let init = () => {
               if (initialized) return true;
               if (window[constants.sharedWindowObjectNames.configVariable] === undefined) return false;
@@ -815,8 +872,11 @@
               if (config.type === undefined || config.type !== constants.typeCastGtmVariableConfig) return false;
               let flushInterval = config[constants.config.flushInterval];
               let flushSize = config[constants.config.flushSize];
-              let trackerName = config[constants.config.trackerName];
-              let appName = config[constants.config.appName];
+              trackerName = config[constants.config.trackerName];
+              appName = config[constants.config.appName];
+              // Capture the error endpoint as soon as a valid config is available so even an
+              // emitter-init failure below can already be reported.
+              errorLoggingEndpoint = config[constants.config.errorLoggingEndpoint] ?? null;
               let emitterEndpoint = config[constants.config.emitterEndpoint] ?? config.endpoint;
               try {
                   emitter = new CollecionesEmitter(emitterEndpoint, flushSize, flushInterval);
@@ -825,6 +885,7 @@
                   return true;
               } catch (e) {
                   console.error('Error initializing CollecionesEmitter:', e);
+                  reportError(e, { phase: 'init' });
                   return false;
               }
           };
@@ -835,6 +896,15 @@
               if (!tracker) return false;
               if (!arg || typeof arg !== 'object') return false;
 
+              // GTM variables can resolve to numbers/booleans or be left empty. Coerce
+              // entity/action/actor names to a string so a mistyped or empty config value
+              // cannot throw inside CollecionesEvent (formatToCamelCase) and drop the event.
+              const toEventName = (value) => {
+                  if (typeof value === 'string') return value;
+                  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+                  return '';
+              };
+
               const normalizeIdentifiers = (identifiers) => {
                   if (Array.isArray(identifiers)) {
                       return identifiers.flatMap(identifier => {
@@ -970,24 +1040,27 @@
               };
 
               const populateEvent = (eventArg, event) => {
-                  event.setEntity(eventArg.entity);
-                  event.setAction(eventArg.action);
+                  event.setEntity(toEventName(eventArg.entity));
+                  event.setAction(toEventName(eventArg.action));
 
                   normalizeIdentifiers(eventArg.identifiers).forEach(identifier => {
                       if (typeof identifier !== 'object' || identifier === null) return;
-                      if (!identifier.name || !identifier.value) return;
+                      // Reject only an absent name or a null/undefined value; falsy-but-valid
+                      // values such as 0 or '' must still be kept (matches addCollectionItem).
+                      if (!identifier.name || identifier.value == null) return;
                       event.setIdentifier(identifier.name, identifier.value);
                   });
 
-                  if (eventArg.actor?.entity) {
-                      event.setActor(eventArg.actor.entity);
+                  const actorName = toEventName(eventArg.actor?.entity ?? eventArg.actor?.name);
+                  if (actorName) {
+                      event.setActor(actorName);
                       let identifiers = eventArg.actor?.identifiers;
                       if (!Array.isArray(identifiers)) {
-                          identifiers = identifiers?.[eventArg.actor.entity] ?? identifiers;
+                          identifiers = identifiers?.[actorName] ?? identifiers;
                       }
                       normalizeIdentifiers(identifiers).forEach(identifier => {
                           if (typeof identifier !== 'object' || identifier === null) return;
-                          if (!identifier.name || !identifier.value) return;
+                          if (!identifier.name || identifier.value == null) return;
                           event.setActorIdentifier(identifier.name, identifier.value);
                       });
                   }
@@ -995,15 +1068,30 @@
                   const relations = eventArg?.relations ?? eventArg?.rerelations;
                   if (relations && typeof relations === 'object') {
                       Object.keys(relations).forEach(relationName => {
+                          const relationIdentifiers = relations[relationName];
                           event.setReference(relationName);
-                          Object.keys(relations[relationName]).forEach(identifierName => {
-                              event.setReferenceIdentifier(relationName, identifierName, relations[relationName][identifierName]);
-                          });
+                          // A relation can be declared while its identifier object is left empty
+                          // (an unfilled GTM variable resolves to undefined/null). Guard against
+                          // non-object values so Object.keys cannot throw and drop the event.
+                          if (relationIdentifiers && typeof relationIdentifiers === 'object') {
+                              Object.keys(relationIdentifiers).forEach(identifierName => {
+                                  event.setReferenceIdentifier(relationName, identifierName, relationIdentifiers[identifierName]);
+                              });
+                          }
                       });
                   }
-                  if (eventArg?.adjectives && typeof eventArg.adjectives === 'object') {
+                  // Adjectives may arrive as an array of values or as an object keyed by adjective.
+                  if (Array.isArray(eventArg?.adjectives)) {
+                      eventArg.adjectives.forEach(adjective => {
+                          if (typeof adjective === 'string' && adjective.length > 0) {
+                              event.addAdjective(adjective);
+                          }
+                      });
+                  } else if (eventArg?.adjectives && typeof eventArg.adjectives === 'object') {
                       Object.keys(eventArg.adjectives).forEach(adjectiveName => {
-                          event.addAdjective(adjectiveName, eventArg.adjectives[adjectiveName]);
+                          if (adjectiveName.length > 0) {
+                              event.addAdjective(adjectiveName);
+                          }
                       });
                   }
 
@@ -1022,10 +1110,23 @@
                   let added = 0;
                   arg.events.forEach(eventArg => {
                       if (!eventArg || typeof eventArg !== 'object') return;
-                      if (!eventArg.entity || !eventArg.action) return;
-                      const event = group.addEvent();
-                      populateEvent(eventArg, event);
-                      added++;
+                      if (!toEventName(eventArg.entity) || !toEventName(eventArg.action)) return;
+                      // Build the event before registering it so a single malformed event cannot
+                      // throw and take the whole group (including its valid siblings) down with it.
+                      try {
+                          const event = new CollecionesEvent();
+                          populateEvent(eventArg, event);
+                          group.addEvent(event);
+                          added++;
+                      } catch (e) {
+                          console.error('Colleciones: skipped malformed grouped event', e);
+                          reportError(e, {
+                              phase: 'group',
+                              rawEvent: eventArg,
+                              entity: eventArg?.entity,
+                              action: eventArg?.action
+                          });
+                      }
                   });
                   if (added === 0) return false;
                   // Apply the semantic group name AFTER addEvent calls: each addEvent invalidates
@@ -1037,14 +1138,14 @@
                   return true;
               }
 
-              if (!arg.entity || !arg.action) return false;
+              if (!toEventName(arg.entity) || !toEventName(arg.action)) return false;
               const event = new CollecionesEvent();
               populateEvent(arg, event);
               tracker.track(event);
               return true;
           };
 
-          let flush = () => {
+          let flushInternal = () => {
               if (!init()) {
                   return;
               }
@@ -1063,7 +1164,35 @@
               while (processedQueueLength < queue.length) {
                   const args = queue[processedQueueLength];
                   processedQueueLength += 1;
-                  track(args);
+                  // Never let one bad queue entry abort the flush loop: the index has already
+                  // advanced, so an uncaught throw here would permanently skip the rest of the batch.
+                  try {
+                      track(args);
+                  } catch (e) {
+                      console.error('Colleciones: failed to process queued event', e);
+                      reportError(e, {
+                          phase: 'flush',
+                          rawEvent: args,
+                          entity: args?.entity,
+                          action: args?.action
+                      });
+                  }
+              }
+          };
+
+          // Overarching safety net. The per-event / per-group catches above exist for
+          // RECOVERY (they keep the loop alive), so they intentionally sit inside the loop.
+          // This wrapper catches everything else our own runtime can throw — init, queue
+          // bookkeeping, or any path we forgot to guard — so nothing fails silently again.
+          // It only fires for genuinely unhandled throws (the inner catches swallow theirs),
+          // so there is no double reporting. Scope is our runtime only: page-level errors
+          // from other scripts are deliberately not captured here.
+          let flush = () => {
+              try {
+                  flushInternal();
+              } catch (e) {
+                  console.error('Colleciones: unexpected runtime failure', e);
+                  reportError(e, { phase: 'runtime' });
               }
           };