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

Revision as of 07:20, 5 May 2025

Latest revision as of 05:37, 30 May 2025

(3 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 url = `/wiki/Special:Contributions/${ip}`;

const userTalk = new Set();

const abortController{ =start, newend } = AbortControllerip.getRange();

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

try {

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

const html = await fetch(url, { signal: abortController.signal }).then(res => res.text());

constlet parserurl = new DOMParser()null;

let pagesFetched = 0;

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

let errors = false;

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

forif (const link of talkLinksvalidPrefix) {

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

const title = link.title;

}

if (title) userTalk.add(title);

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++;

} catch (error) {

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

}

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

return userTalk;

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) {

Line 356 ⟶ 422:

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

}

constlet userTalk = await getUserTalkPages(ip);

let userTalkMethod;

if (!userTalk.size) {

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

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

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

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

userTalkMethod = "enumerate";

contentContainer.appendChild(noContributionsMessage);

} else {

return;

userTalk = await getUserTalkPages(ip);

userTalkMethod = "contributions";

if (!userTalk.length) {

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

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

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

contentContainer.appendChild(resultMessage);

return;

}

}

const infoResponseinfoResponses = await apiPromise.getall({

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

action: 'query',

action: 'query',

titles: Array.from(userTalk).slice(0, 50).join('|'),

prop titles: titles.join('info|'),

format prop: 'jsoninfo|revisions',

format: 'json',

formatversion: 2

formatversion: 2

});

}))

const pages = infoResponse.query.pages

);

.filter(page => !page.missing)

const pages = infoResponses

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

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

.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;">An error occurred while retrieving timestamps for user talk pages in 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 386 ⟶ 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 428 ⟶ 513:

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

if (heading) {

heading.innerHTMLtextContent = 'Range calculator';

}

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

Line 640 ⟶ 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 655 ⟶ 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);

}

});