Sware: 1 revision imported

2025-11-04T17:55:23Z

1 revision imported

← Older revision	Revision as of 17:55, 4 November 2025
(No difference)

wikt>Surjection at 17:29, 19 December 2024

2024-12-19T17:29:45Z

New page

// {{documentation}}
// <nowiki>
// implicit dependencies : mediawiki.Title, ext.gadget.catfixRegrouper-Data
/* jshint maxerr:1048576, strict:true, undef:true, latedef:true, esversion:6 */
/* global $, mw, RegrouperMetadata */

/* data is in [[MediaWiki:Gadget-catfixRegrouper-Data.js]] */

// characters to ignore when looking for the initial in a title.
// this is embedded inside a RegExp character class
const REGROUPER_INITIALS = "-";

function safeUpperCase(text, dottedDotlessI) {
if (dottedDotlessI)
return text.replace(/i/g, "İ").toUpperCase();
else
return text.toUpperCase();
}

function safeLowerCase(text, dottedDotlessI) {
if (dottedDotlessI)
return text.replace(/I/g, "ı").toLowerCase();
else
return text.toLowerCase();
}

function titleCase(text, lang, sc) {
return safeUpperCase(text.charAt(0), this.dottedDotlessI)
+ safeLowerCase(text.substring(1), this.dottedDotlessI);
}

function defaultGroup(title, lang, sc) {
if (title.length < 1) return undefined;
const cleaned = title.replace(this._clean_regex, "");
if (this.initials) {
const initialMatch = cleaned.match(this._initials_regex);
if (initialMatch) {
return titleCase(initialMatch[0], lang, sc);
}
if (!this.initialFallback) return undefined;
}

title = cleaned || title;
return titleCase(title.charAt(0), lang, sc);
}

function makeGroup(groupText) {
const groupDiv = document.createElement("div");
groupDiv.className = "mw-category-group";
const groupH3 = document.createElement("h3");
groupH3.textContent = groupText;
groupDiv.append(groupH3);
const groupUl = document.createElement("ul");
groupDiv.append(groupUl);
return [groupDiv, groupUl];
}

function getLiText(el) {
const child = $(el).find("a, span").first();
const rawText = el.textContent || el.innerText;
return (child.length > 0 && child.text()) || rawText;
}

jQuery(() => {
'use strict';

let catfix;

// Apply only to pages in the Category namespace
// containing an element with the id "catfix".
// Set window.disableCatfixRegrouper to true to prevent this script from running.
if (!(!window.disableCatfixRegrouper
&& mw.config.get('wgNamespaceNumber') === 14
&& (catfix = $(".catfix")).length))
return;
catfix = catfix[0];

const catfixSpan = catfix.querySelector("span");
if (!catfixSpan) return;

const regrouperMeta = new RegrouperMetadata();

// Get the language name and script catfix.
const langName = decodeURIComponent(catfix.getAttribute("data-anchor").replace(/_/g, " "));
catfix = catfix.getElementsByTagName("*")[0] || document.createElement("span");

const lang = catfixSpan.getAttribute("lang");
const defaultSc = catfixSpan.classList[0] || "None";
const cachedScriptData = {};

if (!lang)
return;

const UNPREFIXED_NAMESPACES = ["", "Talk", "Citations"];
const PREFIXED_NAMESPACES = ["Appendix", "Appendix talk", "Reconstruction", "Reconstruction talk"];

function isEntry(namespaceName, pageName) {
// main, Talk, Citations,
// Reconstruction/Appendix (Talk) if it starts with language name and "/"
return UNPREFIXED_NAMESPACES.indexOf(namespaceName) !== -1
|| (PREFIXED_NAMESPACES.indexOf(namespaceName) !== -1
&& pageName.slice(0, langName.length + 1) === langName + "/");
}

const formattedNamespaces = mw.config.get("wgFormattedNamespaces");
const regrouperData = regrouperMeta.getByLang(lang);
if (!regrouperData) return;

// set up stuff for the default regrouper
regrouperData._clean_regex = new RegExp("^[" + ((regrouperData.ignoreAdd || "") + (regrouperData.ignore || REGROUPER_INITIALS)) + "]+");
if (regrouperData.initials)
regrouperData._initials_regex = new RegExp("^" + regrouperData.initials.source, regrouperData.initials.flags);

const groupFunction = regrouperData.group;
const detectScriptFunction = regrouperData.detectScript;

function getGroup(pageTitle, oldGroup) {
const titleobj = new mw.Title(pageTitle);
const namespaceId = titleobj.getNamespaceId();
const namespaceName = formattedNamespaces[namespaceId];
const pageName = titleobj.getMainText();

if (!isEntry(namespaceName, pageName))
return oldGroup;

// verify language prefix if the namespace should have one
let formattedTitle = pageName;
const langPrefix = langName + "/";
if (PREFIXED_NAMESPACES.indexOf(namespaceName) !== -1) {
if (formattedTitle.startsWith(langPrefix)) {
formattedTitle = formattedTitle.substring(langPrefix.length);
} else {
return oldGroup;
}
}

// ignore unsupported titles unless the language data requests otherwise
if (formattedTitle.startsWith("Unsupported titles/") && !regrouperData.unsupported)
return oldGroup;

// script detection
let sc = defaultSc;
if (detectScriptFunction)
sc = detectScriptFunction.call(regrouperData, formattedTitle, lang, sc, namespaceId) || sc;

let scData = cachedScriptData[sc];
if (!scData)
scData = cachedScriptData[sc] = regrouperMeta.getBySc(sc) || {};

let newGroup = true;
// the language group function may return true to fall back
if (groupFunction)
newGroup = groupFunction.call(regrouperData, formattedTitle, lang, sc, namespaceId);
if (newGroup === true && scData.group)
newGroup = scData.group.call(regrouperData, formattedTitle, lang, sc, namespaceId);
if (newGroup === true)
newGroup = defaultGroup.call(regrouperData, formattedTitle, lang, sc, namespaceId);

return newGroup || oldGroup;
}

const GROUP_QUERY = "#mw-pages > .mw-content-ltr .mw-category-group";

let regroupOk = true;
const regroupData = new Map();
// Process each group in the category listing.
jQuery(GROUP_QUERY)
.each(function () {
// Get the existing group.
const group = $(this).find("h3").first().text();
if (!group) {
// Failed to get group -- something has gone wrong.
regroupOk = false;
return;
}

$(this).find("li")
.each(function () {
try {
const liText = getLiText(this);
const newGroup = getGroup(liText, group);
regroupData.set(liText, newGroup);
} catch (e) {
console.error(e);
regroupOk = false;
}
});
});

// Find the existing groups, which we will delete.
const groups = jQuery(GROUP_QUERY);
// Cannot regroup if there are no groups.
if (!groups.length) return;

const parent = groups.first().parent()[0];
if (!parent) return;
const fragment = document.createDocumentFragment();

if (regroupOk) {
let lastGroup, groupUl;
jQuery(GROUP_QUERY + " li")
.each(function () {
const liText = getLiText(this);
const newGroup = regroupData.get(liText) || "";
if (lastGroup !== newGroup) {
const elements = makeGroup(newGroup);
const groupDiv = elements[0];
fragment.appendChild(groupDiv);
groupUl = elements[1];
lastGroup = newGroup;
}
groupUl.appendChild(this);
});

groups.remove();
parent.appendChild(fragment);
}
});

// </nowiki>

MediaWiki:Gadget-catfixRegrouper.js - Revision history

Sware: 1 revision imported

wikt>Surjection at 17:29, 19 December 2024