UFC 326 Max Holloway v Charles Oliveira 2 LIVE: Stream info, results, updates and more from BMF title rematch

li.appendChild(document.createTextNode(item.headline));

const a = document.createElement(“a”);
a.href = `#${item.anchorId}`; // Set the href attribute
a.innerHTML = `View post

`; // Set the text content

li.appendChild(a);

return li;
}

function addScriptSrcToHead(src) {
let s = document.createElement(“script”);
// expectation is that that is the primary script element in the top
let insertion = document.getElementsByTagName(“script”)[0];
s.async = true;
s.src = src;
insertion.parentNode.insertBefore(s, insertion);
}

function refreshScripts( fragment ) {
let scripts = fragment.querySelectorAll(“script”);
for ( let script of scripts ) {
let freshScript = document.createElement(“script”);
// copy attributes
let attrs = script.attributes;
for ( let attr of attrs ) {
freshScript.setAttribute( attr.name, attr.value );
}
// copy inner script code. #718, #782
freshScript.innerHTML = script.innerHTML;
script.parentNode.replaceChild( freshScript, script );
}
}

function reverseEvents(updated_events){

const events = Object.entries(updated_events);

// Reverse the order of the entries
events.reverse();

// Convert the reversed entries back to an object
return Object.fromEntries(events);
}

function fetchUpdatedEvents() {

const apiUrl = getUpdatedEventEndpointUrl(postId);

fetch(apiUrl)
.then(response => response.json())
.then(updatedEvents => {

// Find the events container
let key_points = document.querySelector(“.grv-live-blog-key-points”);

// if we had no key points to start out with but have some now we want to create the div and ul
// for it to populate
if(updatedEvents.key_points.length > 0) {

if (!key_points) {
// Element doesn’t exist, create it
key_points = document.createElement(“div”);
key_points.className = “grv-live-blog-key-points”;

// Create and append

to the brand new element
const heading = document.createElement(“h5”);
heading.textContent = “Key points”;
key_points.appendChild(heading);

// Create and append

to the brand new element
const ul = document.createElement(“ul”);
ul.className = “grv-live-blog-key-points-list”;
key_points.appendChild(ul);

const glb_wrapper = document.getElementById(“glb-wrapper”);

if (glb_wrapper) {
// Insert the brand new element before the wrapper
glb_wrapper.parentNode.insertBefore(key_points, glb_wrapper);
}
}

const key_points_list = document.querySelector(“.grv-live-blog-key-points-list”);
key_points_list.innerHTML = “”;

// Update the important thing points
updatedEvents.key_points.forEach(point => {

const point_item = createPointItem(point);
key_points_list.appendChild(point_item);

});

// else we’ve got no key points so lets remove the list
}else{

if (key_points) {
key_points.remove();
}
}

// now take care of the events themselves…
const events_container = document.querySelector(“.wp-block-grvmedia-grv-live-blog”);

// get a map of the prevailing events keyed by id
const existingEvents = Array.from(events_container.querySelectorAll(“.wp-block-grvmedia-grv-live-blog-event”))
.reduce((map, event) => {
map[event.id] = event;
return map;
}, {});

// get the prevailing and updated keys so we will compare
const existingKeys = Object.keys(existingEvents);
const updatedKeys = Object.keys(updatedEvents.updated_blocks);

// find events which can be in existing but not in updated
const keysToRemove = existingKeys.filter(key => !updatedKeys.includes(key));

// remove any events which have been deleted
keysToRemove.forEach(key => {
// Find the element with the corresponding id
const element = document.getElementById(key);

// Remove the element if it exists
if (element) {
element.remove();
}
});

// reverse the events in order that they are in the fitting order if we add multiple…
updatedEvents.updated_blocks = reverseEvents(updatedEvents.updated_blocks);

// loop through each updated event
Object.values(updatedEvents.updated_blocks).forEach(updatedEvent => {

// create temp elem so we will hydrate it from our rendered event after which access the id etc
const parser = recent DOMParser();
const tempEvent = parser.parseFromString(updatedEvent,”text/html”);

// Select the event from our temp container
const eventElement = tempEvent.querySelector(“.wp-block-grvmedia-grv-live-blog-event”);

// Extract the id
const eventId = eventElement ? eventElement.id : null;

// Using a fraction allows us to refresh scripts before attaching to dom
let frag = document.createDocumentFragment();

if (existingEvents[eventId]) {
frag.append( …eventElement.childNodes );
} else {
frag.append( eventElement );
}
refreshScripts( frag );

// if its an existing event replace the content of the event so we dont cause a jump
if (existingEvents[eventId]) {

// get the prevailing event
const event = document.getElementById(eventId);
event.style.minHeight = event.offsetHeight + “px”;

// update its innerHTML and sophistication incase we’ve got modified to featured or breaking etc
event.className = eventElement.className;
event.replaceChildren(…frag.childNodes);

const seeMore = event.querySelector(“.see-more-wrapper.lazy”);
let seeMoreSrc = seeMore?.getAttribute(“data-src”);
if (seeMoreSrc) {
if ( seeMoreSrc.indexOf(‘instagram’) != -1 && window.instgrm ) {
window.instgrm.Embeds?.process();
} else {
addScriptSrcToHead(seeMoreSrc);
}
}

// if its a brand new event add to the highest – TODO: sort order if multiple recent events
} else {
// Create a brand new event
events_container.insertBefore(frag, events_container.firstChild);
}
});
})
.catch(error => {
console.error(“Error fetching updated blocks:”, error);
});
}

document.addEventListener(“DOMContentLoaded”, function() {

function startPolling(postId) {

function fetchPostModifiedDate() {
const url = getPollingEndpointUrl(postId);
fetch(url)
.then(response => response.json())
.then(data => {

// if our post modified date has modified we’ve got an update
if(modifiedDate != data.modified_date) {

// update the modified time to be the brand new modified time
modifiedDate = data.modified_date;

// show the button so a user can refresh
fetchUpdatedEvents();
showRefreshButton();
}
})
.catch(error => {
console.error(“Error fetching post modified date:”, error);
});
}

// Set interval to fetch every 30 seconds
setInterval(fetchPostModifiedDate, 30000); // 30 seconds
}

// Start polling
startPolling(postId);

const refreshButton = document.getElementById(“glb-btn”);

refreshButton.addEventListener(“click”, jumpToLatestEvent);
});