${
badge
? `
`
: escapeHtml(String(item.rank))
}
${escapeHtml(item.name)}
${escapeHtml(item.score)}
`;
}).join("");
}
function pad(number) {
return String(number).padStart(2, "0");
}
function updateCountdown() {
const now = Date.now() + state.serverOffsetMs;
const diff = Math.max(0, Number(state.countdownEndAtMs || 0) - now);
const seconds = Math.floor(diff / 1000);
const days = Math.floor(seconds / 86400);
const hours = Math.floor((seconds % 86400) / 3600);
const minutes = Math.floor((seconds % 3600) / 60);
const secs = seconds % 60;
els.countdown.days.textContent = pad(days);
els.countdown.hours.textContent = pad(hours);
els.countdown.minutes.textContent = pad(minutes);
els.countdown.seconds.textContent = pad(secs);
}
function setupCountdown() {
updateCountdown();
state.countdownTimer = window.setInterval(updateCountdown, 1000);
}
async function copyText(text) {
if (navigator.clipboard?.writeText) {
await navigator.clipboard.writeText(text);
return;
}
const input = document.createElement("textarea");
input.value = text;
input.setAttribute("readonly", "");
input.style.position = "absolute";
input.style.left = "-9999px";
document.body.appendChild(input);
input.select();
document.execCommand("copy");
document.body.removeChild(input);
}
function extractErrorMessage(payload) {
const candidates = [
payload?.errorMsg,
payload?.message,
payload?.errorCodeName,
payload?.code,
];
return candidates.find((item) => trimValue(item)) || "";
}
async function requestJSON(path, options = {}) {
const { method = "GET", headers = {}, body, searchParams } = options;
const url = buildAPIURL(path, searchParams);
const requestHeaders = shouldAttachGatewayHeaders(path) ? state.requestHeaders : {};
const response = await fetch(url.toString(), {
method,
headers: {
Accept: "application/json",
...requestHeaders,
...headers,
},
body,
});
const contentType = response.headers.get("content-type") || "";
const payload = contentType.includes("application/json") ? await response.json() : null;
if (!response.ok || payload?.status === false) {
const message = extractErrorMessage(payload) || `Request failed (${response.status})`;
throw new Error(message);
}
return payload?.body || payload?.data || payload || null;
}
function shouldAttachGatewayHeaders(path) {
const normalizedPath = joinURLPath(path);
return !normalizedPath.startsWith("/public/");
}
function joinURLPath(...parts) {
return `/${parts
.map((part) => trimValue(part).replace(/^\/+|\/+$/g, ""))
.filter(Boolean)
.join("/")}`;
}
function buildAPIURL(path, searchParams = {}) {
const apiPath = joinURLPath(state.apiPrefix, path);
let url;
if (isAbsoluteURL(state.apiBase)) {
url = new URL(apiPath.replace(/^\/+/, ""), state.apiBase);
} else {
url = new URL(joinURLPath(state.apiBase, apiPath), window.location.href);
}
Object.entries(searchParams || {}).forEach(([key, value]) => {
const raw = trimValue(value);
if (raw) {
url.searchParams.set(key, raw);
}
});
return url;
}
function normalizeTaskList(list, taskSet) {
if (!Array.isArray(list) || list.length === 0) {
return cloneTasks(FALLBACK_TASKS[taskSet]);
}
return list.map((item, index) => {
const threshold = Number(item?.threshold || 0);
const goldAmount = Number(item?.goldAmount || 0);
const achieved = Boolean(item?.achieved);
const claimed = Boolean(item?.claimed);
const desc =
taskSet === "quota"
? `Invite ${formatMetric(threshold)} friends to claim ${formatMetric(goldAmount)} coins`
: `Reach ${formatMetric(threshold)} recharge coins to claim ${formatMetric(goldAmount)} coins`;
return {
title: `Milestone ${index + 1}`,
desc,
buttonLabel: claimed ? "Claimed" : achieved ? "Claim" : "Incomplete",
disabled: claimed || !achieved,
claimed,
achieved,
ruleId: Number(item?.ruleId) || 0,
};
});
}
function normalizeRankList(list) {
if (!Array.isArray(list)) {
return [];
}
return list.map((item, index) => {
const rank = Number(item?.rank || index + 1);
const inviteCount = Number(item?.inviteCount || 0);
const rewardGoldCoins = Number(item?.rewardGoldCoins || 0);
const userName = trimValue(item?.nickname) || `User ${trimValue(item?.userId) || rank}`;
const scoreParts = [`${formatMetric(inviteCount)} people`];
if (rewardGoldCoins > 0) {
scoreParts.push(`${formatMetric(rewardGoldCoins)} coins`);
}
return {
rank,
name: userName,
avatar: trimValue(item?.avatar) || DEFAULT_AVATAR,
score: scoreParts.join(" ยท "),
};
});
}
function markTaskClaimed(ruleId) {
["quota", "transport"].forEach((taskSet) => {
state.tasks[taskSet] = (state.tasks[taskSet] || []).map((item) => {
if (Number(item.ruleId) !== Number(ruleId)) {
return item;
}
return {
...item,
claimed: true,
disabled: true,
buttonLabel: "Claimed",
};
});
});
}
function applyRankData(body) {
if (!body || typeof body !== "object") {
state.rankItems = [];
return;
}
state.rankItems = normalizeRankList(body.items);
}
function applyHomeData(body) {
if (!body || typeof body !== "object") {
return;
}
const stats = body.stats || {};
if (body.serverTimeMs) {
state.serverOffsetMs = Number(body.serverTimeMs) - Date.now();
}
if (body.periodEndAtMs) {
state.countdownEndAtMs = Number(body.periodEndAtMs);
}
state.inviteLink = trimValue(body.inviteLink) || state.inviteLink;
state.inviteCode = trimValue(body.inviteCode) || state.inviteCode;
state.downloadUrl = trimValue(body.downloadUrl) || state.downloadUrl;
state.invitees = stats.totalInvitedUsers ?? state.invitees;
state.eligibleVoters = stats.totalValidUsers ?? state.eligibleVoters;
state.rechargeTotal = stats.totalRechargeCoins ?? state.rechargeTotal;
state.myRewards = stats.rewardGoldCoins ?? state.myRewards;
const inviterBindReward = body.inviterBindReward?.goldAmount;
if (inviterBindReward != null) {
state.inviterBindReward = inviterBindReward;
}
const rechargeReward =
body.inviteeRechargeRules?.[0]?.goldAmount ??
body.inviterTotalRechargeTasks?.[0]?.goldAmount;
if (rechargeReward != null) {
state.rechargeReward = rechargeReward;
}
state.tasks.quota = normalizeTaskList(body.inviterValidCountTasks, "quota");
state.tasks.transport = normalizeTaskList(body.inviterTotalRechargeTasks, "transport");
const shareTitle = trimValue(body.shareTitle);
if (shareTitle) {
document.title = shareTitle;
}
}
function applyLandingData(body) {
if (!body || typeof body !== "object") {
return;
}
state.friendName = trimValue(body.inviterNickname) || state.friendName;
state.inviterAvatar = trimValue(body.inviterAvatar) || DEFAULT_AVATAR;
state.downloadUrl = trimValue(body.downloadUrl) || state.downloadUrl;
state.giftReward = body.inviteeReward?.goldAmount ?? state.giftReward;
const inviteCode = trimValue(body.inviteCode);
if (inviteCode) {
state.landingCode = inviteCode;
state.inviteCode = inviteCode;
}
const shareTitle = trimValue(body.shareTitle);
if (shareTitle) {
document.title = shareTitle;
}
}
function buildDownloadURL(downloadUrl, inviteCode) {
const rawURL = trimValue(downloadUrl);
const code = trimValue(inviteCode);
if (!rawURL || !code) {
return rawURL;
}
try {
const url = new URL(rawURL, window.location.href);
if (url.hostname.includes("play.google.com")) {
const referrer = new URLSearchParams(url.searchParams.get("referrer") || "");
setPlayInstallReferrer(referrer, code);
removeTopLevelInviteCodeParams(url.searchParams);
url.searchParams.set("referrer", referrer.toString());
return url.toString();
}
setInviteCodeParams(url.searchParams, code);
return url.toString();
} catch {
const separator = rawURL.includes("?") ? "&" : "?";
const params = new URLSearchParams();
setInviteCodeParams(params, code);
return `${rawURL}${separator}${params.toString()}`;
}
}
function setInviteCodeParams(searchParams, code) {
searchParams.set("code", code);
searchParams.set("invitationCode", code);
searchParams.set("inviteCode", code);
}
function setPlayInstallReferrer(searchParams, code) {
searchParams.set("invite_code", code);
searchParams.set("source", "share");
}
function removeTopLevelInviteCodeParams(searchParams) {
["code", "invitationCode", "inviteCode", "invite_code"].forEach((name) => {
searchParams.delete(name);
});
}
async function fetchHomeData() {
if (!state.authorization) {
return false;
}
const body = await requestJSON("/app/h5/invite-campaign/home", {
headers: {
Authorization: state.authorization,
},
});
applyHomeData(body);
return true;
}
async function fetchRankData() {
if (!state.authorization) {
return false;
}
const body = await requestJSON("/app/h5/invite-campaign/rank", {
headers: {
Authorization: state.authorization,
},
searchParams: {
limit: 50,
},
});
applyRankData(body);
return true;
}
async function fetchLandingData() {
if (!state.landingCode) {
return false;
}
const body = await requestJSON("/public/h5/invite-campaign/landing", {
searchParams: {
code: state.landingCode,
},
});
applyLandingData(body);
return true;
}
async function refreshPageData() {
try {
if (state.view === "gift") {
await fetchLandingData();
} else {
const hasHome = await fetchHomeData();
if (hasHome) {
await fetchRankData();
}
}
} catch (error) {
const message = trimValue(error?.message);
if (message) {
showToast(message);
}
} finally {
renderStats();
renderTasks();
renderRankList();
}
}
async function claimTask(ruleId) {
if (!ruleId) {
return;
}
if (!state.authorization) {
showToast("Token is missing");
return;
}
state.pendingClaimRuleId = ruleId;
renderTasks();
try {
const body = await requestJSON("/app/h5/invite-campaign/tasks/claim", {
method: "POST",
headers: {
Authorization: state.authorization,
"Content-Type": "application/json",
},
body: JSON.stringify({ ruleId }),
});
markTaskClaimed(ruleId);
showToast(body?.alreadyClaimed ? "Already claimed" : "Claim succeeded");
await fetchHomeData().catch(() => {});
await fetchRankData().catch(() => {});
} catch (error) {
showToast(trimValue(error?.message) || "Claim failed");
} finally {
state.pendingClaimRuleId = 0;
renderStats();
renderTasks();
renderRankList();
}
}
function bindEvents() {
els.taskTabs.forEach((button) => {
button.addEventListener("click", () => {
state.taskSet = normalizeTaskSet(button.getAttribute("data-task-set"));
renderTasks();
});
});
els.navButtons.forEach((button) => {
button.addEventListener("click", () => {
const nextView = button.getAttribute("data-nav-view") || "invite";
setView(nextView);
if (nextView === "rank") {
fetchRankData()
.then(renderRankList)
.catch((error) => showToast(trimValue(error?.message) || "Rank load failed"));
}
});
});
els.copyButtons.forEach((button) => {
button.addEventListener("click", async () => {
const target = button.getAttribute("data-copy-target");
const value = target === "invite-code" ? state.inviteCode : currentInviteShareURL();
try {
await copyText(trimValue(value));
showToast(target === "invite-code" ? "Invitation code copied" : "Invitation link copied");
} catch (error) {
showToast("Copy failed");
}
});
});
els.taskList.addEventListener("click", (event) => {
const button = event.target.closest("[data-rule-id]");
if (!(button instanceof HTMLButtonElement)) {
return;
}
const ruleId = Number(button.getAttribute("data-rule-id") || 0);
if (!ruleId || button.disabled) {
return;
}
claimTask(ruleId);
});
els.downloadButton.addEventListener("click", () => {
if (!state.downloadUrl) {
showToast("Download link is not configured");
return;
}
window.location.href = buildDownloadURL(state.downloadUrl, state.landingCode || state.inviteCode);
});
}
async function init() {
renderStats();
renderTasks();
renderRankList();
bindEvents();
setView(state.view);
setupCountdown();
await connectToApp();
await refreshPageData();
}
init();