Update transcript-tracer.js

transcript-tracer.js

@@ -21,6 +21,8 @@ var ttTimeOffset = 0;
 var ttAutoScroll = null;
 var ttClickable = false;
 
+var dict = {};
+var nodes = [];
 
 // Prepare transcripts and media players
 function loadTranscriptTracer(options=null) {
@@ -31,7 +33,7 @@ function loadTranscriptTracer(options=null) {
     });
     return;
   }
-  
+
   // Save user-provided options to configuration variables
   if (options) {
     if ('blockSelector' in options) ttBlockSelector = options.blockSelector;
@@ -41,7 +43,7 @@ function loadTranscriptTracer(options=null) {
     if ('autoScroll' in options) ttAutoScroll = options.autoScroll;
     if ('clickable' in options) ttClickable = options.clickable;
   }
-  
+
   // Reset Transcript Tracer to prevent unexpected behavior if loadTranscriptTracer() is called more than once
   if (ttIsInitialized) {
     if (ttTranscripts) for (const transcript of ttTranscripts) {
@@ -56,7 +58,7 @@ function loadTranscriptTracer(options=null) {
       element.outerHTML = element.innerHTML;
     });
   }
-  
+
   // Set a few global state variables
   ttIsInitialized = true;
   ttTranscripts = document.getElementsByClassName('tt-transcript');
@@ -67,9 +69,9 @@ function loadTranscriptTracer(options=null) {
     var transcript = ttTranscripts[t];
     // Skip transcript if it's not linked to any media files
     if (!transcript.dataset.ttMediaUrls) continue;
-  
+
     transcript.dataset.ttTranscript = t;
-  
+
     // Loop through text nodes to add spans (tt-word, tt-whitespace)
     // Method of iterating text nodes thanks to https://stackoverflow.com/a/34700627/1349044
     var iter = document.createNodeIterator(transcript, NodeFilter.SHOW_TEXT);
@@ -79,7 +81,7 @@ function loadTranscriptTracer(options=null) {
       if (text.replace(/\s/g, '').length != 0) {
         var spannedText = '<span class="tt-word">' + text.replace(/(\s+)/g, '</span><span class="tt-whitespace">$1</span><span class="tt-word">') + '</span>';
         spannedText = spannedText.replaceAll('<span class="tt-word"></span>', '');
-        
+
         // Replace text node with spanned text
         const template = document.createElement('template');
         template.innerHTML = spannedText;
@@ -88,11 +90,11 @@ function loadTranscriptTracer(options=null) {
       }
     }
   }
-  
+
   for (const mediaPlayer of ttMediaPlayers) {
     // Link related transcript(s)
     linkTranscripts(mediaPlayer);
-    
+
     // Add event listener to media player
     mediaPlayer.addEventListener('play', function(e) {
       if (ttActivePlayer != e.currentTarget) {
@@ -113,11 +115,29 @@ function loadTranscriptTracer(options=null) {
       if (ttCurrentEvent) ttCurrentEvent = null;
     });
   }
+
+  // ====================================================================================================
+
+  if (nodes.length > 0) nodes = []; dict = {};
+  var transcript = ttTranscripts[0];
+  var listIndex= -1;
+  for (const x of transcript.children) {
+    for (const wordElement of x.children) {
+      listIndex = listIndex + 1;
+      // Note: manually add extra information
+      wordElement.listIndex = listIndex;
+      nodes.push(wordElement);
+    }
+  }
+  
+  // ====================================================================================================
+
 }
 
 
 // Link media player to relevant transcripts
 function linkTranscripts(mediaPlayer) {
+
   var trackElement = mediaPlayer.querySelector('track[kind="metadata"]')
 
   var mediaPlayerSourceUrls = [];
@@ -125,12 +145,12 @@ function linkTranscripts(mediaPlayer) {
   var mediaPlayerSourceElements = mediaPlayer.querySelectorAll('source');
   if (mediaPlayerSrc) mediaPlayerSourceUrls.push(mediaPlayerSrc);
   if (mediaPlayerSourceElements) for (const s of mediaPlayerSourceElements) mediaPlayerSourceUrls.push(s.src);
-  
+
   // If there's nothing to link, return
   if (!trackElement || !trackElement.getAttribute('src') || mediaPlayerSourceUrls.length == 0) return;
-  
+
   // Fetch WebVTT content and link related transcripts
-  for (const transcript of ttTranscripts) {    
+  for (const transcript of ttTranscripts) {
     for (const mediaUrl of mediaPlayerSourceUrls) {
       if (transcript.dataset.ttMediaUrls.includes(mediaUrl)) {
         mediaPlayer.dataset.ttLinkedMediaUrl = mediaUrl;
@@ -146,26 +166,26 @@ function linkTranscripts(mediaPlayer) {
   function linkTranscript(mediaPlayer, vttContent, transcript) {
     var wordTimings = parseVttToWordTimings(vttContent);
     transcript.dataset.ttCurrentMediaUrl = mediaPlayer.dataset.ttLinkedMediaUrl;
-    
+
     function normalizedWord(word) {
       // Convert to lowercase, normalize, and remove anything that's not a letter or number
       return word.toLowerCase().normalize('NFD').replace(/[^\p{L}\p{N}]/gu, '');
     }
-    
+
     // Add metadata to block and phrase containers (if ttBlockSelector and ttPhraseSelector are defined)
     var blockContainers = ttBlockSelector ? transcript.querySelectorAll(ttBlockSelector) : [];
     for (let c = 0; c < blockContainers.length; c++) blockContainers[c].dataset.ttBlock = c;
     var phraseContainers = ttPhraseSelector ? transcript.querySelectorAll(ttPhraseSelector) : [];
     for (let c = 0; c < phraseContainers.length; c++) phraseContainers[c].dataset.ttPhrase = c;
-    
+
     // Add metadata to each word span, and build timed events list
     var timedEvents = [];
     var wordTimingsIndex = 0;
     var wordSpans = transcript.getElementsByClassName('tt-word');
     for (let s = 0; s < wordSpans.length; s++) {
       var span = wordSpans[s];
-    
-      // Find the next word timing object that matches the current span's text            
+
+      // Find the next word timing object that matches the current span's text
       var initialWordTimingsIndex = wordTimingsIndex;
       var maxFuzzyWordTimingsIndex = Math.min(wordTimingsIndex + ttAlignmentFuzziness, wordTimings.length - 1);
       while (normalizedWord(span.innerText) != normalizedWord(wordTimings[wordTimingsIndex].text) && wordTimingsIndex <= maxFuzzyWordTimingsIndex) {
@@ -176,17 +196,20 @@ function linkTranscripts(mediaPlayer) {
         wordTimingsIndex = initialWordTimingsIndex;
         continue;
       }
-      
+
       // Get the block, phrase, and word index
       blockIndex = ttBlockSelector ? (span.closest(ttBlockSelector)?.dataset?.ttBlock ?? null) : wordTimings[wordTimingsIndex].blockIndex;
       phraseIndex = ttPhraseSelector ? (span.closest(ttPhraseSelector)?.dataset?.ttPhrase ?? null) : wordTimings[wordTimingsIndex].phraseIndex;
       wordIndex = wordTimings[wordTimingsIndex].wordIndex;
-      
+
       // Add block, phrase, and word index as metadata on the span
       span.dataset.ttBlock = blockIndex;
       span.dataset.ttPhrase = phraseIndex;
       span.dataset.ttWord = wordIndex;
 
+      // We no longer needs this!
+      dict[wordIndex] = span.listIndex;
+
       // Add timed event to timed events list
       if (timedEvents.length != 0 && wordTimings[wordTimingsIndex].startSeconds == timedEvents[timedEvents.length-1].seconds) {
         timedEvents[timedEvents.length-1].currentWordIndexes.push(wordIndex);
@@ -198,7 +221,7 @@ function linkTranscripts(mediaPlayer) {
           'blockIndex': blockIndex,
         });
       }
-    
+
       wordTimingsIndex += 1;
     }
 
@@ -219,7 +242,7 @@ function linkTranscripts(mediaPlayer) {
       }
       return null;
     }
-    
+
     // Add metadata to block and phrase containers (if ttBlockSelector and ttPhraseSelector aren't defined)
     if (!ttBlockSelector) {
       var count = wordTimings[wordTimings.length-1].blockIndex + 1;
@@ -237,12 +260,12 @@ function linkTranscripts(mediaPlayer) {
         if (phraseContainer) phraseContainer.dataset.ttPhrase = c;
       }
     }
-    
+
     // Sort timed events list by time
-    timedEvents = timedEvents.sort(function(a, b) { 
+    timedEvents = timedEvents.sort(function(a, b) {
       return a.seconds - b.seconds;
     })
-    
+
     // Add reference data to ttLinkedDataByMediaUrl
     var transcriptIndex = parseInt(transcript.dataset.ttTranscript);
     ttLinkedDataByMediaUrl[mediaPlayer.dataset.ttLinkedMediaUrl] = {
@@ -271,20 +294,20 @@ function linkTranscripts(mediaPlayer) {
 // Unlink transcript from previous VTT
 function unlinkTranscript(transcript) {
   clearHighlightedWords(transcript);
-  
+
   var ttLinkedElements = transcript.querySelectorAll('[data-tt-word]');
   for (const element of ttLinkedElements) {
     element.dataset.ttWord = '';
     element.dataset.ttPhrase = '';
     element.dataset.ttBlock = '';
   }
-  
+
   var mediaUrl = transcript.dataset.ttCurrentMediaUrl;
   if (mediaUrl) {
     delete ttLinkedDataByMediaUrl[mediaUrl]
     transcript.dataset.ttCurrentMediaUrl = '';
   }
-  
+
   for (const word of document.querySelectorAll('.tt-word')) {
     word.removeEventListener('click', handleWordClick);
   }
@@ -299,14 +322,14 @@ function unlinkTranscript(transcript) {
 // Convert WebVTT into a wordTimings list
 function parseVttToWordTimings(vttContent) {
   var wordTimings = [];
-  
+
   // Split WebVTT at each double line break
   var vttSegments = vttContent.split(/\r?\n\r?\n/);
   if (vttSegments.length == 0 || !vttSegments[0].startsWith('WEBVTT')) {
     console.error('Error: Invalid VTT file. See https://developer.mozilla.org/en-US/docs/Web/API/WebVTT_API');
     return;
   }
-  
+
   // Loop through each segment of the WebVTT
   // WebVTT documentation: https://developer.mozilla.org/en-US/docs/Web/API/WebVTT_API
   var cueWordCounter = 0;
@@ -314,10 +337,10 @@ function parseVttToWordTimings(vttContent) {
   var cueBlockCounter = 0;
   for (let s = 0; s < vttSegments.length; s++) {
     var segment = vttSegments[s];
-    
+
     // Skip segment if it's not a cue
     if (segment.startsWith('WEBVTT') || /^STYLE\s/.test(segment) || /^NOTE\s/.test(segment)) continue;
-  
+
     // Convert VTT timestamps to seconds
     function convertVttTimestampToSeconds(vttTimestamp) {
       var parts = vttTimestamp.trim().split(':');
@@ -329,7 +352,7 @@ function parseVttToWordTimings(vttContent) {
       }
       return seconds;
     }
-    
+
     // Parse cue
     var cueIdentifier = cuePayload = '';
     var cueStartSeconds = cueEndSeconds = null;
@@ -354,7 +377,7 @@ function parseVttToWordTimings(vttContent) {
             wordStartSeconds = convertVttTimestampToSeconds(match[1].replace('<', '').replace('>', ''));
             word = match[2];
           }
-          
+
           // Push word to wordTimings list
           if (word) {
             wordTimings.push({
@@ -373,7 +396,7 @@ function parseVttToWordTimings(vttContent) {
     }
     cueBlockCounter += 1;
   }
-  
+
   return wordTimings;
 }
 
@@ -386,42 +409,42 @@ var ttNextEvent = null;
 function ttTimeUpdate(e) {
   // If the current player isn't active or doesn't have data, return
   if (!ttActivePlayer || e.currentTarget != ttActivePlayer || !(ttActivePlayer.dataset.ttLinkedMediaUrl in ttLinkedDataByMediaUrl)) return;
-  
+
   var adjustedCurrentTime = ttActivePlayer.currentTime + (ttTimeOffset * -1);
   var ttData = ttLinkedDataByMediaUrl[ttActivePlayer.dataset.ttLinkedMediaUrl];
-  
+
   // Make sure the correct transcript is selected
   if (!ttCurrentTranscript || ttCurrentTranscript.dataset.ttTranscript != ttData.transcriptIndex) {
     ttCurrentTranscript = document.querySelector(`[data-tt-transcript="${ttData.transcriptIndex}"]`);
   }
-  
+
   // If before the first event, after the last event, or within the range of the current event, return
   if (ttCurrentEvent && (ttCurrentEvent.seconds < ttData.timedEvents[0].seconds || ttCurrentEvent.seconds > ttData.timedEvents[ttData.timedEvents.length-1].seconds)) return;
   if (ttCurrentEvent && ttNextEvent && ttCurrentEvent.seconds <= adjustedCurrentTime && ttNextEvent.seconds > adjustedCurrentTime) return;
-  
+
   // Clear words that were highlighted from the previous event
   clearHighlightedWords(ttCurrentTranscript);
-  
+
   // Add highlights for the current event
   for (let t = 0; t < ttData.timedEvents.length; t++) {
     if (ttData.timedEvents[t].seconds <= adjustedCurrentTime && (!ttData.timedEvents[t+1] || adjustedCurrentTime < ttData.timedEvents[t+1]?.seconds)) {
-      
+
       ttPreviousEvent = ttData.timedEvents[t-1] || null;
       ttCurrentEvent = ttData.timedEvents[t];
       ttNextEvent = ttData.timedEvents[t+1] || null;
-      
+
       // Mark blocks
       if (ttCurrentEvent.blockIndex != null) {
         var blockElements = ttCurrentTranscript.querySelectorAll(`[data-tt-block="${ttCurrentEvent.blockIndex}"]`);
         for (let b = 0; b < blockElements.length; b++) blockElements[b].classList.add((b==0 && !blockElements[b].classList.contains('tt-word')) ? 'tt-current-block-container' : 'tt-current-block');
       }
-      
+
       // Mark phrases
       if (ttCurrentEvent.phraseIndex != null) {
         var phraseElements = ttCurrentTranscript.querySelectorAll(`[data-tt-phrase="${ttCurrentEvent.phraseIndex}"]`);
         for (let p = 0; p < phraseElements.length; p++) phraseElements[p].classList.add((p==0 && !phraseElements[p].classList.contains('tt-word')) ? 'tt-current-phrase-container' : 'tt-current-phrase');
       }
-      
+
       // Mark words
       if (ttCurrentEvent.currentWordIndexes.length > 0) {
         for (const wordIndex of ttCurrentEvent.currentWordIndexes) {
@@ -433,7 +456,7 @@ function ttTimeUpdate(e) {
           wordElement.classList.add('tt-previous-word');
         }
       }
-      
+
       // Auto-scroll to the highlighted text
       if (ttAutoScroll && !ttActivePlayer.paused && ttActivePlayer.duration != 0) {
         var scrollOptions = { behavior: 'smooth', block: 'nearest', inline: 'nearest' }
@@ -443,9 +466,39 @@ function ttTimeUpdate(e) {
           document.querySelector('.tt-current-phrase-container').scrollIntoView(scrollOptions);
         } else if (ttAutoScroll == 'word') {
           document.querySelector('.tt-current-word').scrollIntoView(scrollOptions);
+
+          word = document.querySelector('.tt-current-word');
+
+          var current_word = word;
+          var current_index = word.listIndex;
+          var current_rect = word.getBoundingClientRect();
+          var current_bottom = current_rect.bottom;
+
+          var index = current_index;
+
+          var rect = word.getBoundingClientRect();
+          var bottom = rect.bottom;
+
+          while (index < nodes.length) {
+            word = nodes[index];
+            rect = word.getBoundingClientRect();
+            bottom = rect.bottom;
+            if (current_bottom < bottom) break;
+            index = index + 1;
+          }
+          word.scrollIntoView(scrollOptions);
+
+          var end_bottom = nodes[nodes.length - 1].getBoundingClientRect().bottom;
+
+          if (current_bottom == end_bottom) {
+            var objDiv = document.getElementById("transcript");
+            objDiv.scrollTop = objDiv.scrollHeight;
+
+          }
+
         }
       }
-      
+
       break;
     }
   }
@@ -467,16 +520,16 @@ function handleWordClick(e) {
   var wordElement = e.currentTarget;
   var wordIndex = wordElement.dataset.ttWord;
 
-  if (wordElement.className == "tt-whitespace" || wordIndex === undefined) return;   
-  
+  if (wordElement.className == "tt-whitespace" || wordIndex === undefined) return;
+
   var transcript = wordElement.closest('.tt-transcript');
-  var mediaUrl = transcript.dataset.ttCurrentMediaUrl;  
+  var mediaUrl = transcript.dataset.ttCurrentMediaUrl;
   var startSeconds = ttLinkedDataByMediaUrl[mediaUrl].wordTimings[wordIndex].startSeconds
 
   ttLinkedDataByMediaUrl[mediaUrl].mediaElement.currentTime = startSeconds;
 
   var ttData = ttLinkedDataByMediaUrl[mediaUrl];
-  
+
   // Make sure the correct transcript is selected
   if (!ttCurrentTranscript || ttCurrentTranscript.dataset.ttTranscript != ttData.transcriptIndex) {
     ttCurrentTranscript = document.querySelector(`[data-tt-transcript="${ttData.transcriptIndex}"]`);
@@ -484,7 +537,7 @@ function handleWordClick(e) {
 
   // Clear words that were highlighted from the previous event
   clearHighlightedWords(ttCurrentTranscript);
-  
+
   // Mark words
   wordElement.classList.add('tt-current-word');
 
@@ -492,7 +545,7 @@ function handleWordClick(e) {
     if (wordElement.classList.contains('tt-current-word')) break;
     wordElement.classList.add('tt-previous-word');
   }
-  
+
 }
 
 // Handle when a word in the transcript with an event listener is clicked
@@ -500,8 +553,8 @@ function handleWordDBClick(e) {
   var wordElement = e.currentTarget;
   var wordIndex = wordElement.dataset.ttWord;
 
-  if (wordElement.className == "tt-whitespace" || wordIndex === undefined) return;  
-  
+  if (wordElement.className == "tt-whitespace" || wordIndex === undefined) return;
+
   var transcript = wordElement.closest('.tt-transcript');
   var mediaUrl = transcript.dataset.ttCurrentMediaUrl;
   var startSeconds = ttLinkedDataByMediaUrl[mediaUrl].wordTimings[wordIndex].startSeconds
@@ -509,7 +562,7 @@ function handleWordDBClick(e) {
   ttLinkedDataByMediaUrl[mediaUrl].mediaElement.currentTime = startSeconds;
 
   var ttData = ttLinkedDataByMediaUrl[mediaUrl];
-  
+
   // Make sure the correct transcript is selected
   if (!ttCurrentTranscript || ttCurrentTranscript.dataset.ttTranscript != ttData.transcriptIndex) {
     ttCurrentTranscript = document.querySelector(`[data-tt-transcript="${ttData.transcriptIndex}"]`);
@@ -517,7 +570,7 @@ function handleWordDBClick(e) {
 
   // Clear words that were highlighted from the previous event
   clearHighlightedWords(ttCurrentTranscript);
-  
+
   // Mark words
   wordElement.classList.add('tt-current-word');
 
@@ -532,61 +585,39 @@ function handleWordDBClick(e) {
   }
 }
 
-
 function handleSelection() {
 
   // Get selection
   var selection = document.getSelection();
-  if (selection.type != "Range") return;  
+  if (selection.type != "Range") return;
 
   // ====================================================================================================
-  
+
   // These can be obtained simply with `startWordElement`
   var transcript = selection.baseNode.parentNode.closest('.tt-transcript');
   var mediaUrl = transcript.dataset.ttCurrentMediaUrl;
-  
-  // ====================================================================================================
-  
-  var dict = {};
-  var nodes = [];
-  var listIndex = -1; 
-  for (const x of transcript.children) {
-    for (const wordElement of x.children) {
-      listIndex = listIndex + 1;
-      // Note: manually add extra information
-      wordElement.listIndex = listIndex;
-      nodes.push(wordElement);
-      if (wordElement.className != "tt-whitespace") {
-        wordIndex = wordElement.dataset.ttWord;
-        // TODO: We no longer need this after we inject the list index information into `wordElement`.
-        dict[wordIndex] = listIndex;
-      }
-    } 
-  }
-  console.log(nodes);
-  console.log(dict);
 
   // ====================================================================================================
-  
+
   var startNode = selection.baseNode;
   var startWordElement = startNode.parentNode;
-  
-  // Used for highlight  
+
+  // Used for highlight
   var startWordElementForHighlight = startWordElement
-  
+
   while (startWordElementForHighlight.className == "tt-whitespace") {
     var index = startWordElementForHighlight.listIndex + 1;
     if (index >= nodes.length) break;
     startWordElementForHighlight = nodes[index];
   }
-  
+
   // This could be `undefined`!
   var startWordIndexForHighlight = startWordElementForHighlight.dataset.ttWord;
   // This is always defined.
   var startWordListIndexForHighlight = startWordElementForHighlight.listIndex;
-  
+
   // Used for computing the start seconds
-  var startWordElementForTime = startWordElementForHighlight;  
+  var startWordElementForTime = startWordElementForHighlight;
 
   // No time specified for some words --> we compute the starting time with the first element where the time information is provided.
   // (This could go beyond the selected religon!)
@@ -606,20 +637,11 @@ function handleSelection() {
     startSeconds = ttLinkedDataByMediaUrl[mediaUrl].wordTimings[startWordIndexForTime].startSeconds;
   }
 
-  console.log(startWordElement);
-  console.log(startWordElementForHighlight);
-  console.log(startWordIndexForHighlight);
-  console.log(startWordListIndexForHighlight);
-  console.log(startWordElementForTime);
-  console.log(startWordIndexForTime);
-  console.log(startWordListIndexForTime);
-  console.log(startSeconds);
-
   // ====================================================================================================
 
   var endNode = selection.extentNode;
   var endWordElement = endNode.parentNode;
-  
+
   // Used for highlight
   var endWordElementForHighlight = endWordElement;
 
@@ -639,13 +661,13 @@ function handleSelection() {
 
   // Forward to the next element (if possible)
   if ((endWordElementForTime.listIndex + 1) < nodes.length) {
-    endWordElementForTime = nodes[endWordElementForTime.listIndex + 1];  
+    endWordElementForTime = nodes[endWordElementForTime.listIndex + 1];
   }
-    
+
   while (endWordElementForTime.className == "tt-whitespace" || (endWordElementForTime.dataset.ttWord === undefined)) {
     var index = endWordElementForTime.listIndex + 1;
     if (index >= nodes.length) break;
-    endWordElementForTime = nodes[index];  
+    endWordElementForTime = nodes[index];
   }
 
   // This could still be `undefined`.
@@ -653,7 +675,7 @@ function handleSelection() {
   // Let's get the `listIndex`.
   var endWordListIndexForTime = endWordElementForTime.listIndex;
 
-  var endSeconds = null;  
+  var endSeconds = null;
   if (endWordIndexForTime !== undefined) {
     endSeconds = ttLinkedDataByMediaUrl[mediaUrl].wordTimings[endWordIndexForTime].startSeconds;
     if (endWordElement.listIndex == nodes.length - 1) {
@@ -661,18 +683,9 @@ function handleSelection() {
     }
   }
   
-  console.log(endWordElement);
-  console.log(endWordElementForHighlight);
-  console.log(endWordIndexForHighlight);
-  console.log(endWordListIndexForHighlight);
-  console.log(endWordElementForTime);
-  console.log(endWordIndexForTime);
-  console.log(endWordListIndexForTime);
-  console.log(endSeconds);
-  
   return
-  
-  // ====================================================================================================  
+
+  // ====================================================================================================
   // Mark selection