User:Daniel Quinlan/Scripts/RangeHelper.js: Difference between revisions

Revision as of 05:57, 1 May 2025

Latest revision as of 05:37, 30 May 2025

(5 intermediate revisions by the same user not shown)

Line 33:

version: this.version

});

}

enumerate() {

if (this.version != 4) {

throw new Error('can only enumerate IPv4 addresses');

}

const count = 1n << BigInt(32 - this.mask);

let current = this.masked(this.mask).ip;

return Array.from({ length: Number(count) }, () =>

IPAddress.#bigIntToIPv4(current++)

);

}

Line 46 ⟶ 57:

}

return uppercase ? ipString.toUpperCase() : ipString;

}

getRange() {

const size = this.version === 4 ? 32 : 128;

const effectiveMask = this.effectiveMask;

const hostBits = BigInt(size - effectiveMask);

const start = this.ip & (~0n << hostBits);

const end = start | ((1n << hostBits) - 1n);

return {

start: new IPAddress({ ip: start, mask: null, version: this.version }),

end: new IPAddress({ ip: end, mask: null, version: this.version })

};

}

inRange(other) {

if (!(other instanceof IPAddress)) return false;

if (this.version !== other.version) return false;

const { start, end } = this.getRange();

return other.ip >= start.ip && other.ip <= end.ip;

}

Line 241 ⟶ 271:

const heading = document.querySelector('#firstHeading');

if (heading) {

heading.innerHTMLtextContent = `Range blocks for ${ip}`;

}

const contentContainer = document.querySelector('#mw-content-text');

Line 284 ⟶ 314:

// display talk pages for IP range

async function displayRangeTalk(ip) {

async function getUserTalkPages(ip, maxPages = 32) {

const userTalk = new Set();

const { start, end } = ip.getRange();

const prefix = commonPrefix(start.toString(true), end.toString(true));

const validPrefix = /^\w+[.:]\w+[.:]/.test(prefix);

let url = null;

let pagesFetched = 0;

let errors = false;

if (validPrefix) {

url = `/wiki/Special:PrefixIndex?prefix=${encodeURIComponent(prefix)}&namespace=3`;

}

while (url && pagesFetched < maxPages && !errors) {

try {

const html = await fetch(url).then(res => res.text());

const parser = new DOMParser();

const fetched = parser.parseFromString(html, 'text/html');

const links = fetched.querySelectorAll('ul.mw-prefixindex-list > li > a');

for (const link of links) {

const ipText = link.textContent;

const pageIp = IPAddress.from(ipText);

if (pageIp && ip.inRange(pageIp)) {

userTalk.add(`User talk:${ipText}`);

}

}

const nextLink = fetched.querySelector('.mw-prefixindex-nav a');

if (nextLink && nextLink.textContent.includes('Next page') && nextLink.href) {

url = nextLink.href;

} else {

url = null;

}

} catch (error) {

console.error('Error fetching usertalk pages:', error);

errors = true;

break;

}

pagesFetched++;

}

if (!validPrefix || errors || pagesFetched === maxPages) {

url = `/wiki/Special:Contributions/${ip}?limit=500`;

try {

const html = await fetch(url).then(res => res.text());

const parser = new DOMParser();

const fetched = parser.parseFromString(html, 'text/html');

const talkLinks = fetched.querySelectorAll('.mw-contributions-list a.mw-usertoollinks-talk:not(.new)');

for (const link of talkLinks) {

const title = link.title;

if (title) userTalk.add(title);

}

} catch (error) {

console.error('Error fetching usertalk pages:', error);

}

}

return Array.from(userTalk);

}

function timeAgo(timestamp) {

const delta = (Date.now() - new Date(timestamp)) / 1000;

Line 304 ⟶ 388:

'.vector-menu-content-list #ca-nstab-user',

'.vector-menu-content-list #ca-protect',

'.vector-menu-content-list #ca-talk',

'.vector-menu-content-list #ca-watch',

'.vector-menu-content-list #ca-wikilove',

Line 311 ⟶ 396:

'.vector-menu-content-list #t-urlshortener-qrcode',

'.vector-menu-content-list #t-whatlinkshere',

'.vector-menu-content-list #tw-block',

'.vector-menu-content-list #tw-rpp',

'.vector-menu-content-list #tw-unlink',

'.vector-menu-content-list #tw-warn',

'.vector-menu-content-list #twinkle-talkback',

'.vector-menu-content-list #twinkle-welcome',

];

for (const selector of elementsToRemove) {

Line 343 ⟶ 422:

blockUser.href = `/wiki/Special:Block/${ip}`;

}

let userTalk;

const response = await api.get({

let userTalkMethod;

action: 'query',

if (ip.version === 4 && ip.mask >= 24) {

list: 'usercontribs',

userTalk = ip.enumerate().map(ipString => `User talk:${ipString}`);

uciprange: `${ip}`,

userTalkMethod = "enumerate";

uclimit: 100,

} else {

format: 'json'

userTalk = await getUserTalkPages(ip);

});

userTalkMethod = "contributions";

const ips = [];

if (!userTalk.length) {

for (const contrib of response.query.usercontribs) {

const contribIPresultMessage = IPAddressdocument.fromcreateElement(contrib.user'p');

resultMessage.style.color = 'var(--color-notice, gray)';

if (contribIP) {

resultMessage.textContent = 'No user talk pages found for recent contributions from this IP range.';

ipListAdd(ips, contribIP);

contentContainer.appendChild(resultMessage);

return;

}

}

const infoResponses = await Promise.all(

if (!ips.length) {

batch(userTalk, 50).map(titles => api.get({

const noContributionsMessage = document.createElement('p');

action: 'query',

noContributionsMessage.innerHTML = '<span style="color:red;">No contributions found for this IP range.</span>';

titles: titles.join('|'),

contentContainer.appendChild(noContributionsMessage);

prop: 'info|revisions',

return;

format: 'json',

}

formatversion: 2

const titles = ips.slice(0, 50).map(ip => `User talk:${ip}`);

}))

const infoResponse = await api.get({

);

action: 'query',

const pages = infoResponses

titles: titles.join('|'),

.flatMap(response => response.query.pages)

prop: 'info',

.filter(page => !page.missing && page.revisions && page.revisions.length > 0)

format: 'json',

formatversion: 2

});

const pages = infoResponse.query.pages

.filter(page => !page.missing)

.map(page => ({

title: page.title,

touchedtimestamp: page.touchedrevisions[0].timestamp,

redirect: !!page.redirect}))

}))

.sort((a, b) => b.touched.localeCompare(a.touched));

.sort((a, b) => b.timestamp.localeCompare(a.timestamp));

if (!pages.length) {

const noTalkPagesMessageresultMessage = document.createElement('p');

if (userTalkMethod === "enumerate") {

noTalkPagesMessage.innerHTML = '<span style="color:red;">No user talk pages found for this IP range.</span>';

resultMessage.style.color = 'var(--color-notice, gray)';

contentContainer.appendChild(noTalkPagesMessage);

resultMessage.textContent = 'No user talk pages found.';

} else {

resultMessage.style.color = 'var(--color-error, red)';

resultMessage.textContent = 'An error occurred while retrieving timestamps for user talk pages in this IP range.';

}

contentContainer.appendChild(resultMessage);

return;

}

Line 387 ⟶ 471:

for (const page of pages) {

const ip = page.title.replace(/^User talk:/, '');

const relativeTime = `${timeAgo(page.touchedtimestamp)} ago`;

const headerText = `== ${relativeTime}: [[Special:Contributions/${ip}|${ip}]] ([[${page.title}|talk]]) ==`;

const inclusionText = `{{${page.title}}}`;

Line 411 ⟶ 495:

}

mw.hook('wikipage.content').fire($(contentContainer));

const twinkleElementsToRemove = [

'.vector-menu-content-list #tw-block',

'.vector-menu-content-list #tw-rpp',

'.vector-menu-content-list #tw-unlink',

'.vector-menu-content-list #tw-warn',

'.vector-menu-content-list #twinkle-talkback',

'.vector-menu-content-list #twinkle-welcome',

];

for (const selector of twinkleElementsToRemove) {

document.querySelector(selector)?.remove();

}

}

Line 418 ⟶ 513:

const heading = document.querySelector('#firstHeading');

if (heading) {

heading.innerHTMLtextContent = 'Range calculator';

}

const contentContainer = document.querySelector('#mw-content-text');

Line 630 ⟶ 725:

}

return wikitext;

}

function batch(items, maxSize) {

const minBins = Math.ceil(items.length / maxSize);

const bins = Array.from({length: minBins}, () => []);

items.forEach((item, i) => {

bins[i % minBins].push(item);

});

return bins;

}

Line 645 ⟶ 749:

const index = ipList.findIndex(i => i.equals(ip));

if (index !== -1) ipList.splice(index, 1);

}

function commonPrefix(a, b) {

let i = 0;

while (i < a.length && i < b.length && a[i] === b[i]) {

i++;

}

return a.slice(0, i);

}

});