@patch-adams/core 1.4.0 → 1.4.3

package/dist/index.js

@@ -1565,24 +1565,12 @@ function generateLrsBridgeCode(options) {
     // Store for document API data
     var documentApiData = null;
     var documentApiFetched = false;
+    var sharedLinkApiData = null;
 
     /**
-     * Fetch document metadata from Bravais API to get GUIDs
-     * Endpoint: /api/v3/documents/{documentId}
+     * Detect Bravais core URL from current page context
      */
-    function fetchDocumentMetadata(documentId, callback) {
-      if (!documentId) {
-        callback(null);
-        return;
-      }
-
-      if (documentApiFetched) {
-        callback(documentApiData);
-        return;
-      }
-
-      // Detect Bravais core URL
-      var coreUrl = null;
+    function detectCoreUrl() {
       var urlsToCheck = [window.location.href, document.referrer];
 
       try {
@@ -1598,13 +1586,91 @@ function generateLrsBridgeCode(options) {
       } catch (e) {}
 
       for (var j = 0; j < urlsToCheck.length; j++) {
-        var match = urlsToCheck[j].match(/(https?:\\/\\/core-[a-zA-Z0-9_-]+\\.bravais\\.com)/);
+        var match = urlsToCheck[j].match(/(https?://core-[a-zA-Z0-9_-]+.bravais.com)/);
         if (match) {
-          coreUrl = match[1];
-          break;
+          return match[1];
         }
       }
+      return null;
+    }
+
+    /**
+     * Fetch shared link data from Bravais API to get the real document ID
+     * Endpoint: /api/v3/sharedLinks/token/{token}
+     * Returns: { documentId, documentName, format, ... }
+     */
+    function fetchSharedLinkData(token, callback) {
+      if (!token) {
+        callback(null);
+        return;
+      }
 
+      var coreUrl = detectCoreUrl();
+      if (!coreUrl) {
+        log('No Bravais core URL detected for shared link fetch');
+        callback(null);
+        return;
+      }
+
+      var apiUrl = coreUrl + '/api/v3/sharedLinks/token/' + token;
+      log('Fetching shared link data from:', apiUrl);
+
+      var xhr = new XMLHttpRequest();
+      xhr.open('GET', apiUrl, true);
+      xhr.withCredentials = true;
+      xhr.setRequestHeader('Accept', 'application/json');
+
+      xhr.onreadystatechange = function() {
+        if (xhr.readyState === 4) {
+          log('Shared link API response status:', xhr.status);
+          if (xhr.status >= 200 && xhr.status < 300) {
+            try {
+              sharedLinkApiData = JSON.parse(xhr.responseText);
+              log('Shared link data received:', sharedLinkApiData);
+              if (sharedLinkApiData.documentId) {
+                log('Real document ID from shared link:', sharedLinkApiData.documentId);
+              }
+              callback(sharedLinkApiData);
+            } catch (e) {
+              warn('Error parsing shared link data:', e);
+              callback(null);
+            }
+          } else {
+            warn('Shared link fetch failed. Status:', xhr.status);
+            callback(null);
+          }
+        }
+      };
+
+      xhr.onerror = function() {
+        log('Network error fetching shared link data');
+        callback(null);
+      };
+
+      try {
+        xhr.send();
+      } catch (e) {
+        warn('Error sending shared link request:', e);
+        callback(null);
+      }
+    }
+
+    /**
+     * Fetch document metadata from Bravais API to get GUIDs
+     * Endpoint: /api/v3/documents/{documentId}
+     */
+    function fetchDocumentMetadata(documentId, callback) {
+      if (!documentId) {
+        callback(null);
+        return;
+      }
+
+      if (documentApiFetched) {
+        callback(documentApiData);
+        return;
+      }
+
+      var coreUrl = detectCoreUrl();
       if (!coreUrl) {
         log('No Bravais core URL detected for document metadata fetch');
         documentApiFetched = true;
@@ -1628,13 +1694,24 @@ function generateLrsBridgeCode(options) {
             try {
               documentApiData = JSON.parse(xhr.responseText);
               log('Document metadata received:', documentApiData);
+              // Validate that we got the required fields
+              if (documentApiData.guid) {
+                log('Document GUID found:', documentApiData.guid);
+              } else {
+                warn('Document API response missing guid field!', documentApiData);
+              }
+              if (documentApiData.latestVersion && documentApiData.latestVersion.guid) {
+                log('Version GUID found:', documentApiData.latestVersion.guid);
+              } else {
+                warn('Document API response missing latestVersion.guid field!', documentApiData);
+              }
               callback(documentApiData);
             } catch (e) {
               warn('Error parsing document metadata:', e);
               callback(null);
             }
           } else {
-            log('Document metadata fetch failed. Status:', xhr.status);
+            warn('Document metadata fetch failed. Status:', xhr.status, 'Response:', xhr.responseText);
             callback(null);
           }
         }
@@ -2018,6 +2095,14 @@ function generateLrsBridgeCode(options) {
     function buildCourseActivityObject() {
       if (!LRS.courseInfo) return null;
 
+      // Warn if we don't have the required GUIDs for Bravais aggregation
+      if (!LRS.courseInfo.guid) {
+        warn('Missing document GUID - statement may fail Bravais aggregation. Using numeric ID:', LRS.courseInfo.documentId);
+      }
+      if (!LRS.courseInfo.versionGuid) {
+        warn('Missing version GUID - statement may fail Bravais aggregation (document_version_id will be null)');
+      }
+
       var obj = {
         objectType: 'Activity',
         id: LRS.courseInfo.id,
@@ -2030,10 +2115,13 @@ function generateLrsBridgeCode(options) {
       // Add Xyleme-format extensions
       obj.definition.extensions = {};
 
-      // Version ID in Xyleme IRI format
+      // Version ID in Xyleme IRI format - REQUIRED for Bravais aggregation
       if (LRS.courseInfo.versionGuid) {
         obj.definition.extensions['versionId'] =
           'http://xyleme.com/bravais/document.version/' + LRS.courseInfo.versionGuid;
+      } else {
+        // Log error - this will cause aggregation failure
+        warn('versionId extension not set - this statement will fail Bravais aggregation!');
       }
 
       // Format (e.g., "SCORM by Rise")
@@ -2639,49 +2727,146 @@ function generateLrsBridgeCode(options) {
     function setupMediaInterceptors() {
       if (!TRACK_MEDIA) return;
 
-      document.addEventListener('play', function(e) {
-        var target = e.target;
-        if (target.tagName === 'VIDEO' || target.tagName === 'AUDIO') {
+      // Track which elements we've already attached listeners to
+      var trackedMedia = new WeakSet();
+
+      // Helper to get media name/title from element or surrounding context
+      function getMediaName(el) {
+        // Check element attributes
+        var name = el.title || el.getAttribute('aria-label') || el.getAttribute('data-name');
+        if (name) return name;
+
+        // Check parent Rise video block for title
+        var videoBlock = findClosest(el, '[data-block-type="video"], .blocks-video, .video-block');
+        if (videoBlock) {
+          var titleEl = videoBlock.querySelector('.video-title, .block-title, [class*="title"]');
+          if (titleEl) return titleEl.textContent.trim();
+        }
+
+        // Use src filename as fallback
+        var src = el.src || el.currentSrc || '';
+        if (src) {
+          var filename = src.split('/').pop().split('?')[0];
+          if (filename && filename.length < 100) return filename;
+        }
+
+        return el.tagName.toLowerCase();
+      }
+
+      // Attach media event listeners to a single element
+      function attachMediaListeners(el) {
+        if (trackedMedia.has(el)) return;
+        trackedMedia.add(el);
+
+        var mediaType = el.tagName.toLowerCase();
+        log('Attaching media listeners to:', mediaType, el.src || el.currentSrc || 'no-src');
+
+        el.addEventListener('play', function() {
+          log('Media play event captured:', mediaType);
           LRS.mediaPlayed({
-            type: target.tagName.toLowerCase(),
-            src: target.src || target.currentSrc || '',
-            name: target.title || target.getAttribute('aria-label') || '',
-            currentTime: target.currentTime || 0,
-            duration: target.duration || 0,
+            type: mediaType,
+            src: el.src || el.currentSrc || '',
+            name: getMediaName(el),
+            currentTime: el.currentTime || 0,
+            duration: el.duration || 0,
             action: 'play'
           });
-        }
-      }, true);
+        });
 
-      document.addEventListener('pause', function(e) {
-        var target = e.target;
-        if (target.tagName === 'VIDEO' || target.tagName === 'AUDIO') {
+        el.addEventListener('pause', function() {
+          // Ignore pause events that fire right before ended
+          if (el.ended) return;
+          log('Media pause event captured:', mediaType);
           LRS.mediaPlayed({
-            type: target.tagName.toLowerCase(),
-            src: target.src || target.currentSrc || '',
-            name: target.title || target.getAttribute('aria-label') || '',
-            currentTime: target.currentTime || 0,
-            duration: target.duration || 0,
+            type: mediaType,
+            src: el.src || el.currentSrc || '',
+            name: getMediaName(el),
+            currentTime: el.currentTime || 0,
+            duration: el.duration || 0,
             action: 'pause'
           });
-        }
-      }, true);
+        });
 
-      document.addEventListener('ended', function(e) {
-        var target = e.target;
-        if (target.tagName === 'VIDEO' || target.tagName === 'AUDIO') {
+        el.addEventListener('ended', function() {
+          log('Media ended event captured:', mediaType);
           LRS.mediaPlayed({
-            type: target.tagName.toLowerCase(),
-            src: target.src || target.currentSrc || '',
-            name: target.title || target.getAttribute('aria-label') || '',
-            currentTime: target.duration || 0,
-            duration: target.duration || 0,
+            type: mediaType,
+            src: el.src || el.currentSrc || '',
+            name: getMediaName(el),
+            currentTime: el.duration || 0,
+            duration: el.duration || 0,
             action: 'completed'
           });
+        });
+      }
+
+      // Scan for and attach listeners to all video/audio elements
+      function scanForMedia(root) {
+        var elements = (root || document).querySelectorAll('video, audio');
+        log('Scanning for media elements, found:', elements.length);
+        for (var i = 0; i < elements.length; i++) {
+          attachMediaListeners(elements[i]);
+        }
+      }
+
+      // Initial scan
+      scanForMedia();
+
+      // Document-level capture for any we might miss
+      document.addEventListener('play', function(e) {
+        var target = e.target;
+        if (target.tagName === 'VIDEO' || target.tagName === 'AUDIO') {
+          // Attach listeners if not already tracked
+          if (!trackedMedia.has(target)) {
+            log('Captured play from untracked media, attaching listeners');
+            attachMediaListeners(target);
+          }
         }
       }, true);
 
-      log('Media interceptors set up');
+      // MutationObserver to detect dynamically added video/audio elements
+      var mediaObserver = new MutationObserver(function(mutations) {
+        var needsScan = false;
+        mutations.forEach(function(mutation) {
+          mutation.addedNodes.forEach(function(node) {
+            if (node.nodeType === 1) {
+              if (node.tagName === 'VIDEO' || node.tagName === 'AUDIO') {
+                attachMediaListeners(node);
+              } else if (node.querySelectorAll) {
+                // Check for nested video/audio
+                var nested = node.querySelectorAll('video, audio');
+                if (nested.length > 0) {
+                  needsScan = true;
+                }
+              }
+            }
+          });
+        });
+        if (needsScan) {
+          scanForMedia();
+        }
+      });
+
+      // Start observing once DOM is ready
+      function startMediaObserver() {
+        if (document.body) {
+          mediaObserver.observe(document.body, {
+            childList: true,
+            subtree: true
+          });
+          log('Media mutation observer started');
+        } else {
+          setTimeout(startMediaObserver, 100);
+        }
+      }
+      startMediaObserver();
+
+      // Periodic rescan for Rise lazy-loaded content
+      setInterval(function() {
+        scanForMedia();
+      }, 3000);
+
+      log('Media interceptors set up (enhanced)');
     }
 
     function setupNavigationInterceptors() {
@@ -2922,7 +3107,7 @@ function generateLrsBridgeCode(options) {
     // ========================================================================
 
     function init() {
-      log('Initializing LRS bridge v2.2.0...');
+      log('Initializing LRS bridge v2.3.0...');
 
       // Extract course info early
       extractCourseInfo();
@@ -2958,9 +3143,18 @@ function generateLrsBridgeCode(options) {
 
       // Fetch document metadata from API to get GUIDs (async)
       // Then send course launched event
+      var sharedLinkToken = LRS.courseInfo ? LRS.courseInfo.sharedLinkToken : null;
       var documentId = LRS.courseInfo ? LRS.courseInfo.documentId : null;
 
       function sendLaunchEvents() {
+        // Log the course info state before sending statements
+        log('Sending launch events with course info:', {
+          id: LRS.courseInfo ? LRS.courseInfo.id : null,
+          guid: LRS.courseInfo ? LRS.courseInfo.guid : null,
+          versionGuid: LRS.courseInfo ? LRS.courseInfo.versionGuid : null,
+          documentId: LRS.courseInfo ? LRS.courseInfo.documentId : null
+        });
+
         if (TRACK_NAVIGATION) {
           LRS.courseLaunched();
           LRS.contentOpened({
@@ -2971,17 +3165,52 @@ function generateLrsBridgeCode(options) {
         }
       }
 
-      if (documentId && !LRS.courseInfo.guid) {
-        // Try to fetch GUIDs from API before sending statements
-        fetchDocumentMetadata(documentId, function(docData) {
+      function fetchDocDataAndSend(docId) {
+        fetchDocumentMetadata(docId, function(docData) {
           if (docData) {
             updateCourseInfoFromApi(docData);
           }
           // Send launch events after API fetch (success or failure)
           setTimeout(sendLaunchEvents, 100);
         });
+      }
+
+      if (!LRS.courseInfo.guid) {
+        // First, try to get real document ID from shared link token
+        // The URL path contains a thin pack file ID, not the real document ID
+        if (sharedLinkToken) {
+          log('Fetching shared link data to get real document ID...');
+          fetchSharedLinkData(sharedLinkToken, function(linkData) {
+            if (linkData && linkData.documentId) {
+              // Got the real document ID from shared link
+              log('Got real document ID from shared link:', linkData.documentId);
+              LRS.courseInfo.documentId = linkData.documentId;
+              // Update shared link name if available
+              if (linkData.documentName) {
+                LRS.courseInfo.sharedLinkName = linkData.documentName;
+              }
+              fetchDocDataAndSend(linkData.documentId);
+            } else if (documentId) {
+              // Fallback to extracted document ID (may be thin pack ID)
+              warn('Could not get document ID from shared link, using extracted ID:', documentId);
+              fetchDocDataAndSend(documentId);
+            } else {
+              // No document ID available
+              warn('No document ID available - statements may fail aggregation');
+              setTimeout(sendLaunchEvents, 100);
+            }
+          });
+        } else if (documentId) {
+          // No shared link token, try with extracted document ID
+          log('No shared link token, fetching document data with ID:', documentId);
+          fetchDocDataAndSend(documentId);
+        } else {
+          // No identifiers available
+          warn('No shared link token or document ID - statements may fail aggregation');
+          setTimeout(sendLaunchEvents, 500);
+        }
       } else {
-        // Already have GUID or no document ID - send after short delay
+        // Already have GUID - send after short delay
         setTimeout(sendLaunchEvents, 500);
       }