613 lines
17 KiB
JavaScript
613 lines
17 KiB
JavaScript
const head = document.querySelector("head");
|
|
const userId = head?.dataset.userId;
|
|
const activityProgressMap = new Map();
|
|
|
|
let instanceUri = head?.dataset.instanceUri;
|
|
let badgeURL = head?.dataset.badgeUrl;
|
|
let socket;
|
|
let badgesLoaded = false;
|
|
|
|
function formatTime(ms) {
|
|
const totalSecs = Math.floor(ms / 1000);
|
|
const hours = Math.floor(totalSecs / 3600);
|
|
const mins = Math.floor((totalSecs % 3600) / 60);
|
|
const secs = totalSecs % 60;
|
|
|
|
return `${String(hours).padStart(1, "0")}:${String(mins).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
|
|
}
|
|
|
|
function formatVerbose(ms) {
|
|
const totalSecs = Math.floor(ms / 1000);
|
|
const hours = Math.floor(totalSecs / 3600);
|
|
const mins = Math.floor((totalSecs % 3600) / 60);
|
|
const secs = totalSecs % 60;
|
|
|
|
return `${hours}h ${mins}m ${secs}s`;
|
|
}
|
|
|
|
function updateElapsedAndProgress() {
|
|
const now = Date.now();
|
|
|
|
for (const el of document.querySelectorAll(".activity-timestamp")) {
|
|
const start = Number(el.dataset.start);
|
|
if (!start) continue;
|
|
|
|
const elapsed = now - start;
|
|
const display = el.querySelector(".elapsed");
|
|
if (display) display.textContent = `(${formatVerbose(elapsed)} ago)`;
|
|
}
|
|
|
|
for (const bar of document.querySelectorAll(".progress-bar")) {
|
|
const start = Number(bar.dataset.start);
|
|
const end = Number(bar.dataset.end);
|
|
if (!start || !end || end <= start) continue;
|
|
|
|
const duration = end - start;
|
|
const elapsed = Math.min(now - start, duration);
|
|
const progress = Math.min(
|
|
100,
|
|
Math.max(0, Math.floor((elapsed / duration) * 100)),
|
|
);
|
|
|
|
const fill = bar.querySelector(".progress-fill");
|
|
if (fill) fill.style.width = `${progress}%`;
|
|
}
|
|
|
|
for (const label of document.querySelectorAll(".progress-time-labels")) {
|
|
const start = Number(label.dataset.start);
|
|
const end = Number(label.dataset.end);
|
|
if (!start || !end || end <= start) continue;
|
|
|
|
const isPaused = now > end;
|
|
const current = isPaused ? end - start : Math.max(0, now - start);
|
|
const total = end - start;
|
|
|
|
const currentEl = label.querySelector(".progress-current");
|
|
const totalEl = label.querySelector(".progress-total");
|
|
|
|
const id = `${start}-${end}`;
|
|
const last = activityProgressMap.get(id);
|
|
|
|
if (isPaused || (last !== undefined && last === current)) {
|
|
label.classList.add("paused");
|
|
} else {
|
|
label.classList.remove("paused");
|
|
}
|
|
|
|
activityProgressMap.set(id, current);
|
|
|
|
if (currentEl) {
|
|
currentEl.textContent = isPaused
|
|
? `Paused at ${formatTime(current)}`
|
|
: formatTime(current);
|
|
}
|
|
if (totalEl) totalEl.textContent = formatTime(total);
|
|
}
|
|
}
|
|
|
|
function loadEffectScript(effect) {
|
|
const existing = document.querySelector(`script[data-effect="${effect}"]`);
|
|
if (existing) return;
|
|
|
|
const script = document.createElement("script");
|
|
script.src = `/public/js/${effect}.js`;
|
|
script.dataset.effect = effect;
|
|
document.head.appendChild(script);
|
|
}
|
|
|
|
function resolveActivityImage(img, applicationId) {
|
|
if (!img) return null;
|
|
|
|
if (img.startsWith("mp:external/")) {
|
|
return `https://media.discordapp.net/external/${img.slice("mp:external/".length)}`;
|
|
}
|
|
|
|
if (img.includes("/https/")) {
|
|
const clean = img.split("/https/")[1];
|
|
return clean ? `https://${clean}` : null;
|
|
}
|
|
|
|
if (img.startsWith("spotify:")) {
|
|
return `https://i.scdn.co/image/${img.split(":")[1]}`;
|
|
}
|
|
|
|
return `https://cdn.discordapp.com/app-assets/${applicationId}/${img}.png`;
|
|
}
|
|
|
|
function buildActivityHTML(activity) {
|
|
const start = activity.timestamps?.start;
|
|
const end = activity.timestamps?.end;
|
|
const now = Date.now();
|
|
const elapsed = start ? now - start : 0;
|
|
const total = start && end ? end - start : null;
|
|
const progress =
|
|
total && elapsed > 0
|
|
? Math.min(100, Math.floor((elapsed / total) * 100))
|
|
: null;
|
|
|
|
let art = null;
|
|
let smallArt = null;
|
|
|
|
if (activity.assets) {
|
|
art = resolveActivityImage(
|
|
activity.assets.large_image,
|
|
activity.application_id,
|
|
);
|
|
smallArt = resolveActivityImage(
|
|
activity.assets.small_image,
|
|
activity.application_id,
|
|
);
|
|
}
|
|
|
|
const activityTypeMap = {
|
|
0: "Playing",
|
|
1: "Streaming",
|
|
2: "Listening",
|
|
3: "Watching",
|
|
4: "Custom Status",
|
|
5: "Competing",
|
|
};
|
|
|
|
const activityType =
|
|
activity.name === "Spotify"
|
|
? "Listening to Spotify"
|
|
: activity.name === "TIDAL"
|
|
? "Listening to TIDAL"
|
|
: activityTypeMap[activity.type] || "Playing";
|
|
|
|
const activityTimestamp =
|
|
start && progress === null
|
|
? `<div class="activity-timestamp" data-start="${start}">
|
|
<span>Since: ${new Date(start).toLocaleTimeString("en-GB", {
|
|
hour: "2-digit",
|
|
minute: "2-digit",
|
|
second: "2-digit",
|
|
})} <span class="elapsed"></span></span>
|
|
</div>`
|
|
: "";
|
|
|
|
const activityButtons =
|
|
activity.buttons && activity.buttons.length > 0
|
|
? `<div class="activity-buttons">
|
|
${activity.buttons
|
|
.map((button, index) => {
|
|
const label = typeof button === "string" ? button : button.label;
|
|
let url = null;
|
|
if (typeof button === "object" && button.url) {
|
|
url = button.url;
|
|
} else if (index === 0 && activity.url) {
|
|
url = activity.url;
|
|
}
|
|
return url
|
|
? `<a href="${url}" class="activity-button" target="_blank" rel="noopener noreferrer">${label}</a>`
|
|
: null;
|
|
})
|
|
.filter(Boolean)
|
|
.join("")}
|
|
</div>`
|
|
: "";
|
|
|
|
const progressBar =
|
|
progress !== null
|
|
? `<div class="progress-bar" data-start="${start}" data-end="${end}">
|
|
<div class="progress-fill" style="width: ${progress}%"></div>
|
|
</div>
|
|
<div class="progress-time-labels" data-start="${start}" data-end="${end}">
|
|
<span class="progress-current">${formatTime(elapsed)}</span>
|
|
<span class="progress-total">${formatTime(total)}</span>
|
|
</div>`
|
|
: "";
|
|
|
|
const isMusic = activity.type === 2 || activity.type === 3;
|
|
|
|
const primaryLine = isMusic ? activity.details : activity.name;
|
|
const secondaryLine = isMusic ? activity.state : activity.details;
|
|
const tertiaryLine = isMusic ? activity.assets?.large_text : activity.state;
|
|
|
|
const activityArt = `<div class="activity-image-wrapper ${art ?? "no-asset"}">
|
|
<img
|
|
class="activity-image${!art ? " no-asset" : ""}"
|
|
src="${art ?? ""}"
|
|
data-name="${activity.name}"
|
|
${activity.assets?.large_text ? `title="${activity.assets.large_text}"` : ""}
|
|
/>
|
|
${`<img class="activity-image-small ${smallArt ?? "no-asset"}" src="${smallArt ?? ""}" ${activity.assets?.small_text ? `title="${activity.assets.small_text}"` : ""}>`}
|
|
</div>`;
|
|
|
|
return `
|
|
<li class="activity">
|
|
<div class="activity-wrapper">
|
|
<div class="activity-type-wrapper">
|
|
<span class="activity-type-label" data-type="${activity.type}">${activityType}</span>
|
|
${activityTimestamp}
|
|
</div>
|
|
<div class="activity-wrapper-inner">
|
|
${activityArt}
|
|
<div class="activity-content">
|
|
<div class="inner-content">
|
|
<div class="activity-top">
|
|
<div class="activity-header ${progress !== null ? "no-timestamp" : ""}">
|
|
<span class="activity-name">${primaryLine}</span>
|
|
</div>
|
|
${secondaryLine ? `<div class="activity-detail">${secondaryLine}</div>` : ""}
|
|
${tertiaryLine ? `<div class="activity-detail">${tertiaryLine}</div>` : ""}
|
|
</div>
|
|
<div class="activity-bottom">
|
|
${activityButtons}
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
${progressBar}
|
|
</div>
|
|
</li>
|
|
`;
|
|
}
|
|
|
|
async function loadBadges(userId, options = {}) {
|
|
const {
|
|
services = [],
|
|
seperated = false,
|
|
cache = true,
|
|
targetId = "badges",
|
|
serviceOrder = [],
|
|
} = options;
|
|
|
|
const params = new URLSearchParams();
|
|
if (services.length) params.set("services", services.join(","));
|
|
if (seperated) params.set("seperated", "true");
|
|
if (!cache) params.set("cache", "false");
|
|
|
|
const url = `${badgeURL}${userId}?${params.toString()}`;
|
|
const target = document.getElementById(targetId);
|
|
if (!target) return;
|
|
|
|
target.classList.add("hidden");
|
|
|
|
try {
|
|
const res = await fetch(url);
|
|
const json = await res.json();
|
|
|
|
if (!res.ok || !json.badges) {
|
|
target.textContent = "Failed to load badges.";
|
|
return;
|
|
}
|
|
|
|
target.innerHTML = "";
|
|
|
|
const badgesByService = json.badges;
|
|
const renderedServices = new Set();
|
|
|
|
const renderBadges = (badges) => {
|
|
for (const badge of badges) {
|
|
const img = document.createElement("img");
|
|
img.src = badge.badge;
|
|
img.alt = badge.tooltip;
|
|
img.title = badge.tooltip;
|
|
img.className = "badge";
|
|
target.appendChild(img);
|
|
}
|
|
};
|
|
|
|
for (const serviceName of serviceOrder) {
|
|
const badges = badgesByService[serviceName];
|
|
if (Array.isArray(badges) && badges.length) {
|
|
renderBadges(badges);
|
|
renderedServices.add(serviceName);
|
|
}
|
|
}
|
|
|
|
for (const [serviceName, badges] of Object.entries(badgesByService)) {
|
|
if (renderedServices.has(serviceName)) continue;
|
|
if (Array.isArray(badges) && badges.length) {
|
|
renderBadges(badges);
|
|
}
|
|
}
|
|
|
|
target.classList.remove("hidden");
|
|
} catch (err) {
|
|
console.error(err);
|
|
target.innerHTML = "";
|
|
target.classList.add("hidden");
|
|
}
|
|
}
|
|
|
|
async function updatePresence(data) {
|
|
const cssLink = data.kv?.css;
|
|
if (cssLink) {
|
|
try {
|
|
const res = await fetch(`/api/css?url=${encodeURIComponent(cssLink)}`);
|
|
if (!res.ok) throw new Error("Failed to fetch CSS");
|
|
|
|
const cssText = await res.text();
|
|
const style = document.createElement("style");
|
|
style.textContent = cssText;
|
|
document.head.appendChild(style);
|
|
} catch (err) {
|
|
console.error("Failed to load CSS", err);
|
|
}
|
|
}
|
|
|
|
const avatarWrapper = document.querySelector(".avatar-wrapper");
|
|
const avatarImg = avatarWrapper?.querySelector(".avatar");
|
|
const usernameEl = document.querySelector(".username");
|
|
|
|
if (!data.discord_user) {
|
|
const loadingOverlay = document.getElementById("loading-overlay");
|
|
if (loadingOverlay) {
|
|
loadingOverlay.innerHTML = `
|
|
<div class="error-message">
|
|
<p>Failed to load user data.</p>
|
|
</div>
|
|
`;
|
|
loadingOverlay.style.opacity = "1";
|
|
avatarWrapper.classList.add("hidden");
|
|
avatarImg.classList.add("hidden");
|
|
usernameEl.classList.add("hidden");
|
|
document.title = "Error";
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!badgesLoaded) {
|
|
loadBadges(userId, {
|
|
services: [],
|
|
seperated: true,
|
|
cache: true,
|
|
targetId: "badges",
|
|
serviceOrder: ["discord", "equicord", "reviewdb", "vencord"],
|
|
});
|
|
badgesLoaded = true;
|
|
}
|
|
|
|
if (avatarImg && data.discord_user?.avatar) {
|
|
const newAvatarUrl = `https://cdn.discordapp.com/avatars/${data.discord_user.id}/${data.discord_user.avatar}`;
|
|
avatarImg.src = newAvatarUrl;
|
|
avatarImg.classList.remove("hidden");
|
|
|
|
const siteIcon = document.getElementById("site-icon");
|
|
|
|
if (siteIcon) {
|
|
siteIcon.href = newAvatarUrl;
|
|
}
|
|
}
|
|
if (usernameEl) {
|
|
const username =
|
|
data.discord_user.global_name || data.discord_user.username;
|
|
usernameEl.textContent = username;
|
|
document.title = username;
|
|
}
|
|
|
|
const platform = {
|
|
mobile: data.active_on_discord_mobile,
|
|
web: data.active_on_discord_web,
|
|
desktop: data.active_on_discord_desktop,
|
|
};
|
|
|
|
let status = "offline";
|
|
if (data.activities.some((activity) => activity.type === 1)) {
|
|
status = "streaming";
|
|
} else {
|
|
status = data.discord_status;
|
|
}
|
|
|
|
for (const el of avatarWrapper.querySelectorAll(".platform-icon")) {
|
|
const platformType = ["mobile-only", "desktop-only", "web-only"].find(
|
|
(type) => el.classList.contains(type),
|
|
);
|
|
|
|
if (!platformType) continue;
|
|
|
|
const active =
|
|
(platformType === "mobile-only" && platform.mobile) ||
|
|
(platformType === "desktop-only" && platform.desktop) ||
|
|
(platformType === "web-only" && platform.web);
|
|
|
|
if (!active) {
|
|
el.remove();
|
|
} else {
|
|
el.setAttribute("class", `platform-icon ${platformType} ${status}`);
|
|
}
|
|
}
|
|
|
|
if (
|
|
platform.mobile &&
|
|
!avatarWrapper.querySelector(".platform-icon.mobile-only")
|
|
) {
|
|
const mobileIcon = document.createElementNS(
|
|
"http://www.w3.org/2000/svg",
|
|
"svg",
|
|
);
|
|
mobileIcon.setAttribute("class", `platform-icon mobile-only ${status}`);
|
|
mobileIcon.setAttribute("viewBox", "0 0 1000 1500");
|
|
mobileIcon.setAttribute("fill", "#43a25a");
|
|
mobileIcon.setAttribute("aria-label", "Mobile");
|
|
mobileIcon.setAttribute("width", "17");
|
|
mobileIcon.setAttribute("height", "17");
|
|
mobileIcon.innerHTML = `
|
|
<path d="M 187 0 L 813 0 C 916.277 0 1000 83.723 1000 187 L 1000 1313 C 1000 1416.277 916.277 1500 813 1500 L 187 1500 C 83.723 1500 0 1416.277 0 1313 L 0 187 C 0 83.723 83.723 0 187 0 Z M 125 1000 L 875 1000 L 875 250 L 125 250 Z M 500 1125 C 430.964 1125 375 1180.964 375 1250 C 375 1319.036 430.964 1375 500 1375 C 569.036 1375 625 1319.036 625 1250 C 625 1180.964 569.036 1125 500 1125 Z"/>
|
|
`;
|
|
avatarWrapper.appendChild(mobileIcon);
|
|
}
|
|
|
|
const updatedStatusIndicator =
|
|
avatarWrapper.querySelector(".status-indicator");
|
|
if (!updatedStatusIndicator) {
|
|
const statusDiv = document.createElement("div");
|
|
statusDiv.className = `status-indicator ${status}`;
|
|
avatarWrapper.appendChild(statusDiv);
|
|
} else {
|
|
updatedStatusIndicator.className = `status-indicator ${status}`;
|
|
}
|
|
|
|
const custom = data.activities?.find((a) => a.type === 4);
|
|
updateCustomStatus(custom);
|
|
|
|
const readmeSection = document.querySelector(".readme");
|
|
|
|
if (readmeSection && data.kv?.readme) {
|
|
const url = data.kv.readme;
|
|
try {
|
|
const res = await fetch(`/api/readme?url=${encodeURIComponent(url)}`);
|
|
if (!res.ok) throw new Error("Failed to fetch readme");
|
|
|
|
const text = await res.text();
|
|
|
|
readmeSection.innerHTML = `<div class="markdown-body">${text}</div>`;
|
|
readmeSection.classList.remove("hidden");
|
|
} catch (err) {
|
|
console.error("Failed to load README", err);
|
|
readmeSection.classList.add("hidden");
|
|
}
|
|
} else if (readmeSection) {
|
|
readmeSection.classList.add("hidden");
|
|
}
|
|
|
|
const filtered = data.activities
|
|
?.filter((a) => a.type !== 4)
|
|
?.sort((a, b) => {
|
|
const priority = { 2: 0, 1: 1, 3: 2 }; // Listening, Streaming, Watching ? should i keep this
|
|
const aPriority = priority[a.type] ?? 99;
|
|
const bPriority = priority[b.type] ?? 99;
|
|
return aPriority - bPriority;
|
|
});
|
|
|
|
const activityList = document.querySelector(".activities");
|
|
const activitiesTitle = document.querySelector(".activity-header");
|
|
|
|
if (activityList && activitiesTitle) {
|
|
if (filtered?.length) {
|
|
activityList.innerHTML = filtered.map(buildActivityHTML).join("");
|
|
activitiesTitle.classList.remove("hidden");
|
|
} else {
|
|
activityList.innerHTML = "";
|
|
activitiesTitle.classList.add("hidden");
|
|
}
|
|
updateElapsedAndProgress();
|
|
getAllNoAsset();
|
|
}
|
|
|
|
if (data.kv?.snow === "true") loadEffectScript("snow");
|
|
if (data.kv?.rain === "true") loadEffectScript("rain");
|
|
if (data.kv?.stars === "true") loadEffectScript("stars");
|
|
|
|
const loadingOverlay = document.getElementById("loading-overlay");
|
|
if (loadingOverlay) {
|
|
loadingOverlay.style.opacity = "0";
|
|
setTimeout(() => loadingOverlay.remove(), 500);
|
|
}
|
|
}
|
|
|
|
function updateCustomStatus(custom) {
|
|
const userInfoInner = document.querySelector(".user-info");
|
|
const customStatus = userInfoInner?.querySelector(".custom-status");
|
|
|
|
if (!userInfoInner) return;
|
|
|
|
if (custom) {
|
|
let emojiHTML = "";
|
|
if (custom.emoji?.id) {
|
|
const emojiUrl = `https://cdn.discordapp.com/emojis/${custom.emoji.id}.${custom.emoji.animated ? "gif" : "png"}`;
|
|
emojiHTML = `<img src="${emojiUrl}" alt="${custom.emoji.name}" class="custom-emoji">`;
|
|
} else if (custom.emoji?.name) {
|
|
emojiHTML = `${custom.emoji.name} `;
|
|
}
|
|
|
|
const html = `
|
|
<p class="custom-status">
|
|
${emojiHTML}${custom.state ? `<span class="custom-status-text">${custom.state}</span>` : ""}
|
|
</p>
|
|
`;
|
|
|
|
if (customStatus) {
|
|
customStatus.outerHTML = html;
|
|
} else {
|
|
userInfoInner.insertAdjacentHTML("beforeend", html);
|
|
}
|
|
} else if (customStatus) {
|
|
customStatus.remove();
|
|
}
|
|
}
|
|
|
|
async function getAllNoAsset() {
|
|
const noAssetImages = document.querySelectorAll(
|
|
"img.activity-image.no-asset",
|
|
);
|
|
|
|
for (const img of noAssetImages) {
|
|
const name = img.dataset.name;
|
|
if (!name) continue;
|
|
|
|
try {
|
|
const res = await fetch(`/api/art/${encodeURIComponent(name)}`);
|
|
if (!res.ok) continue;
|
|
|
|
const { icon } = await res.json();
|
|
if (icon) {
|
|
img.src = icon;
|
|
img.classList.remove("no-asset");
|
|
img.parentElement.classList.remove("no-asset");
|
|
}
|
|
} catch (err) {
|
|
console.warn(`Failed to fetch fallback icon for "${name}"`, err);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (instanceUri) {
|
|
if (!instanceUri.startsWith("http")) {
|
|
instanceUri = `https://${instanceUri}`;
|
|
}
|
|
|
|
const wsUri = instanceUri
|
|
.replace(/^http:/, "ws:")
|
|
.replace(/^https:/, "wss:")
|
|
.replace(/\/$/, "");
|
|
|
|
socket = new WebSocket(`${wsUri}/socket`);
|
|
}
|
|
|
|
if (badgeURL && badgeURL !== "null" && userId) {
|
|
if (!badgeURL.startsWith("http")) {
|
|
badgeURL = `https://${badgeURL}`;
|
|
}
|
|
|
|
if (!badgeURL.endsWith("/")) {
|
|
badgeURL += "/";
|
|
}
|
|
}
|
|
|
|
if (userId && instanceUri) {
|
|
let heartbeatInterval = null;
|
|
|
|
socket.addEventListener("message", (event) => {
|
|
const payload = JSON.parse(event.data);
|
|
|
|
if (payload.op === 1 && payload.d?.heartbeat_interval) {
|
|
heartbeatInterval = setInterval(() => {
|
|
socket.send(JSON.stringify({ op: 3 }));
|
|
}, payload.d.heartbeat_interval);
|
|
|
|
socket.send(
|
|
JSON.stringify({
|
|
op: 2,
|
|
d: {
|
|
subscribe_to_id: userId,
|
|
},
|
|
}),
|
|
);
|
|
}
|
|
|
|
if (payload.t === "INIT_STATE" || payload.t === "PRESENCE_UPDATE") {
|
|
updatePresence(payload.d);
|
|
requestAnimationFrame(() => updateElapsedAndProgress());
|
|
}
|
|
});
|
|
|
|
socket.addEventListener("close", () => {
|
|
if (heartbeatInterval) clearInterval(heartbeatInterval);
|
|
});
|
|
}
|
|
|
|
updateElapsedAndProgress();
|
|
setInterval(updateElapsedAndProgress, 1000);
|