//Forked from [[User:Novem Linguae/Scripts/DetectPromo.js]]
//now highlights the words in the article text and those in the top bar are now clickable
// <nowiki>
/*
- Let reviewer know when certain promotional and POV keywords are detected.
- Displays a bar at the top of the article, listing the detected keywords.
- Highlights detected promotional words with a yellow background and red border within the article text.
- Makes the words in the top bar clickable, scrolling to their first occurrence in the article.
- Added "Report false positive" link to allow users to report incorrect detections.
- Added confirmation dialog explaining false positive criteria before reporting.
*/
class DetectPromo {
/** @type {string[]} */
wordsToSearch = [
'% growth', '6-figure', '7-figure', '8-figure', '9-figure',
'B2B', 'B2C', 'a record', 'acclaimed', 'accomplished',
'are a necessity', 'around the world', 'award winning', 'award-winning',
'beloved', 'best available', 'bestselling', 'boasts', 'comprehensive',
'countless hours', 'create a revolution', 'critical acclaim',
'disrupt', 'drastically', 'dynamic', 'elevate', 'eminent', 'engaging',
'entrepreneur', 'evangelist', 'excelled', 'exceptional', 'exemplified',
'exemplify', 'expert', 'expertise', 'extensive', 'famous', 'fascinating',
'fast growing', 'fast-growing', 'fastest growing', 'fastest-growing',
'finest', 'fully integrated', 'fully-integrated', 'globally',
'globally recognized', 'growing popularity', 'highlights',
'highly accomplished', 'highly praised', 'highly specialized',
'historic', 'honored with', 'hypnotic', 'illustrious', 'impressive',
'indelible', 'inexhaustible', 'influential', 'innovation', 'innovative',
'insights', 'inspired by', 'integrate', 'invaluable', 'leader in',
'leading', 'legendary', 'leverag', 'massive', 'mastermind', 'more than',
'most highly', 'most important', 'most impressive', 'most notable',
'mystical', 'natural charm', 'noteworthy', 'numerous', 'organically',
'outstanding', 'perfect', 'philanthropist', 'picturesque', 'pioneer',
'pioneering', 'popular destination', 'popularity', 'premiere',
'prestigious', 'prominence', 'prominent', 'promising', 'promulgator',
'ranked', 'reinvent', 'remarkable', 'renowed', 'renowned', 'resonating',
'respected', 'revolutionary', 'rising star', 'save millions', 'savvy',
'seamless', 'sensual', 'several offers', 'showcased', 'signature',
'significant', 'soulful', 'spanning', 'state of art', 'state of the art',
'state-of-art', 'state-of-the-art', 'striking', 'super famous',
'tailored', 'tranquility', 'transcend', 'transform', 'underpin',
'ventured into', 'very first', 'visionary', 'wide selection',
'widely used', 'world class', 'world-class', 'worldwide', 'zero to hero'
];
/**
* @type {Object}
* Dictionary of words and their exception patterns
* Each entry is a word and regex pattern that should NOT be flagged
*/
exceptions = {
'leading': /leading\s+to\b/i,
'outstanding': /outstanding\s+warrant/i,
'numerous': /numerous\s+witnesses\b/i,
'significant': /significant\s+blow\b/i
};
/**
* @param {Object} mw
* @param {jQuery} $
*/
constructor(mw, $) {
this.mw = mw;
this.$ = $;
}
async execute() {
if (!this.shouldRunOnThisPage()) {
return;
}
const title = this.mw.config.get('wgPageName');
const wikicode = await this.getWikicode(title);
if (!wikicode) return;
const cleanedWikicode = this.cleanWikicode(wikicode);
const searchResults = this.getSearchResults(cleanedWikicode);
if (searchResults.length > 0) {
this.displayResults(searchResults);
this.highlightPromoWords(searchResults);
}
}
/**
* @param {string[]} searchResults
*/
displayResults(searchResults) {
const MAX_DISPLAYED_RESULTS = 20;
const displayedResults = searchResults.slice(0, MAX_DISPLAYED_RESULTS);
let html = `
<div id="DetectPromo" style="background-color: #ccc; padding: 10px; margin-bottom: 10px; display: flex; justify-content: space-between; align-items: center;">
<div>
<span style="font-weight: bold;">Promotional words detected:</span>
`;
html += displayedResults.map(word =>
`<a href="#" class="promo-word" data-word="${word}" style="color: blue; text-decoration: underline; cursor: pointer;">${word}</a>`
).join(', ');
if (searchResults.length > MAX_DISPLAYED_RESULTS) {
html += ', ...... and more.';
}
html += `</div>
<div>
<a href="#" id="report-false-positive" style="color: #d33; text-decoration: underline; font-size: 0.9em;">Report false positive</a>
</div>
</div>`;
this.$('#contentSub').after(html);
// Add click event listeners for promo words
this.$('.promo-word').on('click', (e) => {
e.preventDefault();
const word = this.$(e.target).data('word');
this.scrollToWord(word);
});
// Add click event listener for false positive reporting
this.$('#report-false-positive').on('click', (e) => {
e.preventDefault();
this.showFalsePositiveDialog(searchResults);
});
}
/**
* Scroll to the first occurrence of a word in the article
* @param {string} word
*/
scrollToWord(word) {
const content = this.$('#mw-content-text');
const regex = new RegExp(`\\b${this.escapeRegEx(word)}\\b`, 'i');
const elements = content.find('*').contents().filter(function() {
return this.nodeType === Node.TEXT_NODE && regex.test(this.textContent);
});
if (elements.length > 0) {
const firstOccurrence = elements[0];
firstOccurrence.parentElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
}
}
/**
* Highlight promotional words with yellow background and red border within the article text
* @param {string[]} searchResults
*/
highlightPromoWords(searchResults) {
const content = this.$('#mw-content-text');
const highlightStyle = 'background-color: yellow; border: 1px solid red; padding: 2px; margin: -2px;';
searchResults.forEach(word => {
const regex = new RegExp(`\\b${this.escapeRegEx(word)}\\b`, 'gi');
content.find('*').contents().filter(function() {
return this.nodeType === Node.TEXT_NODE;
}).each((_, textNode) => {
const text = textNode.textContent;
if (regex.test(text)) {
const newHtml = text.replace(regex, `<span class="promo-highlight" data-word="${word}" style="${highlightStyle}">$&</span>`);
const newElement = document.createElement('span');
newElement.innerHTML = newHtml;
textNode.parentNode.replaceChild(newElement, textNode);
}
});
});
}
/**
* @param {string} wikicode
* @return {string[]} searchResults
*/
getSearchResults(wikicode) {
return this.wordsToSearch.filter(word => {
// Check if the word has exceptions
if (this.exceptions[word.toLowerCase()]) {
// Regular expression to find the word with word boundaries
const wordRegex = new RegExp(`\\b${this.escapeRegEx(word)}\\b`, 'gi');
const text = wikicode;
let match;
let foundPromoUse = false;
// Check each occurrence of the word
while ((match = wordRegex.exec(text)) !== null) {
// Get context around this match (20 chars before and after)
const startPos = Math.max(0, match.index - 20);
const endPos = Math.min(text.length, match.index + word.length + 20);
const context = text.substring(startPos, endPos);
// If this occurrence doesn't match the exception pattern, it's promotional
if (!this.exceptions[word.toLowerCase()].test(context)) {
foundPromoUse = true;
break;
}
}
return foundPromoUse;
} else {
// Regular case, no exceptions
const regEx = new RegExp(`\\b${this.escapeRegEx(word)}\\b`, 'i');
return regEx.test(wikicode);
}
});
}
/**
* @param {string} wikicode
* @return {string} cleanedWikicode
*/
cleanWikicode(wikicode) {
return wikicode
.replace(/\[\[|\]\]/g, '') // Remove [[ ]]
.replace(/<ref[^<]*<\/ref>|<ref[^>]*\/>/gm, ''); // Remove <ref></ref> and <ref />
}
/**
* @return {boolean}
*/
shouldRunOnThisPage() {
const action = this.mw.config.get('wgAction');
const isDiff = this.mw.config.get('wgDiffNewId');
const isDeletedPage = !this.mw.config.get('wgCurRevisionId');
const namespace = this.mw.config.get('wgNamespaceNumber');
const title = this.mw.config.get('wgPageName');
return (
action === 'view' &&
!isDiff &&
!isDeletedPage &&
([0, 118].includes(namespace) || title === 'User:Novem_Linguae/sandbox')
);
}
/**
* @param {string} title
* @return {Promise<string|null>} wikicode
*/
async getWikicode(title) {
try {
const api = new this.mw.Api();
const response = await api.get({
action: 'parse',
page: title,
prop: 'wikitext',
formatversion: '2',
format: 'json'
});
return response.parse.wikitext;
} catch (error) {
console.error('Error fetching wikicode:', error);
return null;
}
}
/**
* Show dialog explaining false positive criteria before reporting
* @param {string[]} detectedWords
*/
showFalsePositiveDialog(detectedWords) {
// Use MediaWiki's OOjs UI dialog framework
mw.loader.using(['oojs-ui-core', 'oojs-ui-windows'], () => {
// Create message dialog
const messageDialog = new OO.ui.MessageDialog({
size: 'medium'
});
// Add dialog to window manager
const windowManager = new OO.ui.WindowManager();
this.$('body').append(windowManager.$element);
windowManager.addWindows([messageDialog]);
// Configure dialog
const config = {
title: 'False Positive Reporting Guidelines',
message: $('<div>')
.append($('<p>').text('You should only report false positives when a promotional word, when combined with another word, is not promotional in context.'))
.append($('<p>').text('For example:'))
.append($('<ul>')
.append($('<li>').text('"outstanding" can be promotional, but "outstanding warrant" is not'))
.append($('<li>').text('"leading" can be promotional, but "leading to" is not'))
),
actions: [
{
action: 'cancel',
label: 'Cancel',
flags: ['safe', 'close']
},
{
action: 'continue',
label: 'Continue',
flags: ['primary', 'progressive']
}
]
};
// Open dialog
windowManager.openWindow(messageDialog, config).closed.then(data => {
if (data && data.action === 'continue') {
this.reportFalsePositive(detectedWords);
}
});
});
}
/**
* Report false positive by redirecting to the talk page
* @param {string[]} detectedWords
*/
reportFalsePositive(detectedWords) {
const currentPage = this.mw.config.get('wgPageName');
// Use exactly the same URL structure as DuplicateReferences
const baseUrl = 'https://en.wikipedia.org/wiki/User_talk:Polygnotus';
const action = 'edit';
const section = 'new';
const preloadtitle = 'Reporting%20%5B%5BUser%3APolygnotus%2FDetectPromo%7CDetectPromo%5D%5D%20false-positive';
// Note the $1 placeholder in the preload parameter - this is key!
const preload = 'User:Polygnotus/$1';
// Format the preloadparams exactly as in the example
const preloadparams = encodeURIComponent(`[[${currentPage}]] ${detectedWords.join(', ')} ~~~~`);
// Construct the final URL to match the example format exactly
const reportURL = `${baseUrl}?action=${action}§ion=${section}&preloadtitle=${preloadtitle}&preload=${preload}&preloadparams%5b%5d=${preloadparams}`;
// Redirect to the report page
window.location.href = reportURL;
}
/**
* @param {string} string
* @return {string} escapedString
*/
escapeRegEx(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
}
$(() => {
mw.loader.using(['mediawiki.api', 'oojs-ui-core', 'oojs-ui-windows']).then(() => {
new DetectPromo(mw, $).execute();
});
});
// </nowiki>
