// Version : 2.6.7
// Last-modified : August 07, 2023
// Author : Alexander Davronov
// Description : Toolbar for copying diff entries from revision/contributions
// pages history on Wikipedia
/***********************************************************************************
***********************************************************************************
** HistoryHelper (Wikipedia script) **
** Copyright (C) 2021- Alex A. Davronov **
** **
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR **
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, **
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE **
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER **
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING **
** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER **
** DEALINGS IN THE SOFTWARE. **
***********************************************************************************
***********************************************************************************/
$(function() {
"use strict";
// -----------------------------------------------------------------------------
// #BROWSER POLYFILLS
// -----------------------------------------------------------------------------s
if (!Object.assign) { Object.assign = jQuery.extend; }
/**
* @param {string} message
* @param {string} indent */
var InvalidArgumentTypeError = class extends TypeError {
constructor(message, indent) {
indent = indent instanceof String ? indent : "";
message = indent + "Invalid Argument: " + message;
super(message);
}
};
// -----------------------------------------------------------------------------
// #UTILS
// -----------------------------------------------------------------------------
/*
* Makes clipboard (temporary buffer) managment easier
* @example: new ClipboardBuffer().copy('foo') // copies 'foo' string to the clipboard
* Borrowed from Collect tracks v.2.js
**/
let ClipboardBuffer = class {
static version = "1.0.0";
constructor(container) {
this.container = container || document.body;
this.id = "clipboard-area";
this.el = this.container.querySelector("#" + this.id);
if (!this.el) {
this.el = document.createElement("textarea");
this.container.appendChild(this.el);
}
this.el.style.position = "absolute";
this.el.style.top = "-9999px";
this.el.contentEditable = true;
this.el.id = this.id;
}
copy(text) {
this.el.value = text;
this.el.select();
var result = document.execCommand("copy");
this.el.blur();
return result;
}
};
/**
* Toolbar for buttons.
* This class is tasked with book keeping of buttons.
* It can retrieve buttons to assing listeners for both pointer and keyboard.
* element which you can style.
* @since 2.6.0
* @example
* let toolbar = new Wiki.Toolbar(document.getElementById(`some-panel`))
* toolbar.addMany([ ...htmlElements or oo.UI.ButtonWidgets ])
*/
// -----------------------------------------------------------------------------
// #WIKI TEXT SYNTAX
// -----------------------------------------------------------------------------
// Wikipedia Classes NameSpace
var Wiki = {};
/**
* @since 2.6.0
*/
Wiki.Text = class extends String {
static options = {}
constructor(rawWikitext, options, C) {
super(rawWikitext)
this.C = Object.assign({}, C || {});
this.options = Object.assign({}, this.constructor.options, options || {});
}
/**
* https://www.mediawiki.org/wiki/ResourceLoader/Core_modules#mediawiki.api
* https://doc.wikimedia.org/mediawiki-core/master/js/#!/api/mw.Api
* https://www.mediawiki.org/wiki/Special:ApiSandbox#action=parse&text=%7B%7BProject:Sandbox%7D%7D&contentmodel=wikitext
* @example render().done((data) => …)
* @returns {mw.API}
*/
render() {
// Get rendered wikitext with no miscelanious things
var api = new mw.Api();
return api.post({
action: `parse`,
format: `json`,
text: this,
contentmodel: `wikitext`,
prop: {
langlinks: false,
categories: false,
categorieshtml: false,
links: false,
parsetree: false,
properties: false
},
preview: true
})
}
};
/** Wikipedia's Template markup as string in the form of {{}}
* https://en.wikipedia.org/wiki/Wikipedia:Anatomy_of_a_template
* @return {TemplateTag} */
Wiki.Text.Tag = class {
static IATE = InvalidArgumentTypeError;
/** Basic Tokens */
static B = "{{";
static D = "|";
static E = "}}";
/**
* @param {String} name - Tag name e.g. diff, oldid2
* @param {params} params - Params of the template: {diff|param1|paramX|….}
*/
constructor(name, params) {
if (new Object(name).constructor !== String) {
throw new this.constructor.IATE(
`Invalid arg: string expected`
);
}
if (!(params instanceof Array)) {
throw new this.constructor.IATE(
"params have to be an array"
);
}
let isParamString;
// Replace non-string by "" (empty) string
params = params.map((param) => {
isParamString = new Object(param) instanceof String;
return isParamString ? param.toString() : "";
});
this.name = name;
this.params = params;
}
valueOf() {
return this.toString();
}
toString() {
// Create `{{name|param0|param1|paramN}}`
let B = this.constructor.B; // Tag token
let D = this.constructor.D; // Tag token
let E = this.constructor.E; // Tag token
let val = "";
val += B;
val += this.name;
for (var param of this.params) {
if (param) val += D + param;
}
val += E;
return val;
}
};
/**
* A container for Rows. Renders them into a string via toStirng()
* @summary Wikipedia table wikitext wrapper
*/
Wiki.Text.Table = class extends String {
static IATE = InvalidArgumentTypeError;
constructor({ cssClasses, rows }, options) {
super();
this.options = Object.assign(
{
caption: `Diffs`,
},
options || {}
);
if (!(rows instanceof Array)) {
throw new this.constructor.IATE("rows have to be an array");
}
this.cssClasses = cssClasses || ``;
this.rows = rows;
}
valueOf() {
return this.toString();
}
toString() {
let rowsStr = this.rows.join("\r\n");
let classAttr = this.cssClasses ? `class="${this.cssClasses}"` : ``;
return `{|${classAttr}\n|+${this.options.caption}\n${rowsStr}\n|}`;
}
};
Wiki.Text.Table.Row = class extends String {
constructor({ arr, value }, options, C) {
if (value) {
throw new Error(`Provide array instead`);
}
let rows = arr.join(`||`);
super(`|-\n|${rows}`);
this.C = C || {};
}
};
Wiki.Text.Table.Header = class extends String {
constructor({ arr, value }, options, C) {
if (value) {
throw new Error(`Provide array instead`);
}
let rows = arr.join(`!!`);
super(`!${rows}`);
this.C = C || {};
}
};
Wiki.Text.Table.Def = class extends String {
constructor(value) {
if (new Object(value).value != null) {
value = obj.value
}
super(`${value}`);
}
};
// -----------------------------------------------------------------------------
// #Wikidate
// -----------------------------------------------------------------------------
// @summary I convert Wikidate into Date and help to format it
Wiki.Date = class extends Date {
constructor(dateStr) {
let wdate = dateStr.split(`, `);
super(wdate.slice(1).concat(wdate[0]).join(`,`));
wdate = null;
}
// Default
static dateFormat = {
dateStyle: `medium`
, timeStyle: "short"
, hour12: false
};
// @para {object} dateFormat - Format object, see MDN: Intl/DateTimeFormat
format(dateFormat) {
return Intl.DateTimeFormat(undefined, dateFormat || this.constructor.dateFormat).format(this);
}
}
// -----------------------------------------------------------------------------
// #REVISIONS ENTRIES WRAPPER
// -----------------------------------------------------------------------------
/**
* @summary Container for elements of Entry class
* @class
*/
Wiki.Revisions = class extends Array {
static IATE = InvalidArgumentTypeError;
/**
* @param {Array<Wiki.Entry>} entries
* @param {HTMLElement} parentEl
* @param {Object} options
* @param {Object} C
*/
constructor(entries, parentEl, options, C) {
super();
// Context
this.C = Object.assign({}, C || {});
this.options = Object.assign({}, options || {});
this.parentEl = parentEl;
this.el = parentEl;
if (entries instanceof Array) {
// throw new this.constructor.IATE(`Array is expected`);
// Sieve only Entry-based instances
this.init(entries);
}
}
/**
* @summary Clean up checkboxes left by previous script run
* @description Use after revisions.fromEl() call
* @param {HTMLElement} rootElement
* @returns {Revisions}
*/
static checkboxesCleanUp(rootElement) {
// Clean up previously created checkboxes
if (rootElement.querySelector(`input[name="select-diff"]`)) {
$(rootElement).find(`input[name="select-diff"]`).parent().remove();
}
return this
} // checkboxesCleanUp end
/**
* Helper to map HTMLElement children of revisions into Entries
* @param {HTMLElement} rawRevisions - An element whose children are going to be wrapped by Entry
* @param {Object} opt - Options for Revisions
* @param {Object} C - Context for Revisions
* @param {Wiki.Revisions.Entry} Entry - Entry constructor
* @param {Object} Eopt - For Entry - Options for Entry
* @param {Object} EC - Wiki UI native checkbox widget
* @returns Revisions
*/
static fromEl(rawRevisions, opt, C, Entry, Eopt, EC) {
if (!(
rawRevisions
&& rawRevisions.constructor == Array
&& rawRevisions.length > 0
)) {
throw this.IATE(`${Wiki.HH.NAME}: fromEl() expects an array with elements`);
}
if (rawRevisions[0].constructor != HTMLLIElement) {
throw this.IATE(`${Wiki.HH.NAME}: fromEl() expects an array of li elements`);
}
EC = Object.assign({ CheckboxInputWidget: OO.ui.CheckboxInputWidget }, EC || {});
let entries = rawRevisions.map((el) => new Entry(el, Eopt, EC));
// Invoking this(…) make this portable
return new this(entries, rawRevisions, opt, C);
}
init(entries) {
for (let i = 0; i < entries.length; i++) {
const entry = entries[i];
if (entry instanceof this.constructor.Entry) {
this[i] = entry;
entry.parent = this;
}
}
}
// Return array of checked entries
checked() {
let checked = [];
for (let i = 0; i < this.length; i++) {
if (this[i].isChecked()) {
checked.push(this[i]);
}
}
// BUG: This uncessarily registered new controls listeners if called via
// built-in Array methods
return new this.constructor(checked, this.parentEl, this.options, this.C);
}
};
// A single revision entry line container
Wiki.Revisions.Entry = class extends Object {
static IATE = InvalidArgumentTypeError;
constructor(el, options, C) {
super();
this.C = Object.assign({}, C || {});
if (!(el instanceof HTMLLIElement)) {
throw new this.constructor.IATE(`<li> element expected`);
}
this.el = el;
this.init(el);
}
init(el) {
// Revision link
let href = el.querySelector(`.mw-changeslist-links > span:nth-child(2) > a`);
if (href == null) {
console.warn(`${Wiki.HH.NAME}: Entry()..init(): history 'prev' link isn't found, falling back to default values`);
this.title = "";
this.diff = "";
this.oldid = "";
} else {
// TODO: BUG ON MAIN PAGE
let urlParams = new URL(href).searchParams;
this.title = urlParams.get(`title`);
this.diff = urlParams.get(`amp;diff`) || urlParams.get(`diff`);
this.oldid = urlParams.get(`amp;oldid`) || urlParams.get(`oldid`);
}
// Date
let date = el.querySelector(`li > a`);
if (date && date.textContent) {
this.date = new Wiki.Date(date.textContent);
}
this.user = el.querySelector("bdi") && (el.querySelector("bdi").textContent ?? "");
let comment = el.querySelector(".comment") ?? "";
// Strip comments from backslash
if (comment && comment.textContent) {
this.comment = el
.querySelector(".comment")
.textContent.replace(/[\(\→]/g, "");
} else {
this.comment = ``;
}
}
/**
* Insert a given el element before entry's first element
* @param {HTMLElement} el - element to be inserted before the first child
*/
insertBefore(el) {
this.el.insertBefore(el, this.el.firstChild);
}
};
/**
* @summary Container for elements of EntryCB class
* @class
* @since 2.6.0
*/
Wiki.Revisions2 = class extends Wiki.Revisions {
/**
* @param {Array<Wiki.Revisions2.EntryCB>} entries
* @param {HTMLElement} parentEl
* @param {Object} options
* @param {Object} C
*/
constructor(entries, parentEl, options, C) {
super(entries, parentEl, options, C);
this.i = 0;
}
init(entries) {
/** @property {Boolean} - Whether any checkbox is checked*/
this.checkboxes = [];
this.checkboxes.parent = this;
this.checkboxes.lastClicked = [];
for (let i = 0; i < entries.length; i++) {
const entry = entries[i];
if (entry instanceof this.constructor.Entry) {
this[i] = entry;
// entry.parent = this;
entry.parent = this;
entry.checkbox.parent = this.checkboxes;
this.checkboxes.push(entry.checkbox);
}
}
}
isAnyChecked() {
return this.some(entry => entry.checkbox.isSelected())
}
checked() {
return this.filter(entry => entry.isChecked());
}
};
/**
* The Entry extended with a checkboxk
* @class
* @since 2.6.0
*/
Wiki.Revisions2.EntryCB = class extends Wiki.Revisions.Entry {
constructor(el, options, C) {
super(el, options, C);
if (this.C.CheckboxInputWidget == null) {
throw new this.constructor.IATE(`CheckboxInputWidget is missing`);
}
// The value is expected to be assigned by external entity
this.parent
this.init(el);
this.initCheckBox();
}
initCheckBox() {
this.checkbox = new this.C.CheckboxInputWidget({
name: `select-diff`,
value: this.el.getAttribute(`data-mw-revid`),
selected: false,
});
this.checkbox.$element[0].style.width = `15px`;
this.checkbox.$element[0].style.height = `15px`;
this.checkbox.$element.mouseleave(function(e) {
if (e.buttons === 1) {
this.setSelected(!this.isSelected());
}
}.bind(this.checkbox));
this.insertBefore(this.checkbox.$element[0]);
}
/**
* @returns {Boolean} - True if checked
*/
isChecked() {
return this.checkbox.isSelected();
}
};
Wiki.Contributions = class extends Wiki.Revisions2 { };
Wiki.Contributions.EntryCB = class extends Wiki.Revisions2.EntryCB {
static IATE = InvalidArgumentTypeError;
static UserName = mw.config.get(`wgRelevantUserName`);
constructor(el, options, C) {
super(el, options, C);
if (!(el instanceof HTMLLIElement)) {
throw new this.constructor.IATE(`<li> element expected`);
}
let context = {}; // The context here stands for imported object
this.C = Object.assign(context, C || {});
this.options = Object.assign({}, options || {});
this.el = el;
this.init(el);
}
init(el) {
// Revision links
let diffEl = el.querySelector(`a.mw-changeslist-diff`) || el.querySelector(`a.mw-changeslist-history`);
if (diffEl == null) {
throw new Error(`${Wiki.HH.NAME}: can't find diff element on collaboration page.`);
}
let href = diffEl.href;
if (href == null) {
throw new Error(`${Wiki.HH.NAME}: Entry()..init(): history 'prev' link isn't found, falling back to default values`)
this.title = "";
this.diff = "";
} else {
let urlParams = new URL(href).searchParams;
this.title = urlParams.get(`title`);
this.diff = this.el.dataset["mwRevid"];
}
this.oldid = `prev`;
this.user = this.constructor.UserName;
// this.user = mw.config.get(`wgRelevantUserName`);
// Date
let date = el.querySelector(`li > a`);
if (date && date.textContent) {
el.querySelector(`li > a`).textContent;
this.date = new Wiki.Date(date.textContent);
} else {
this.date = new Wiki.Date(date.textContent);
}
this.comment = ``;
let commentEl = this.el.querySelector(`.comment`);
if (commentEl) {
this.comment = commentEl.textContent.replace(/[\(\→]/g, "")
}
}
};
Wiki.Toolbar = class extends Map {
static IATE = InvalidArgumentTypeError;
static config = {
id: `toolbar-default`
}
static buttons = {
[`info`]: {
type: `Popup`,
disabled: true,
title: `Click buttons on the right`,
label: `COPY AS`,
icon: `doubleChevronEnd`,
},
[`as.diffs`]: {
title: `Copy selected as {{diff|…}} wikitext`,
id: `as.diffs`,
label: `{{diff}}`,
icon: `code`,
template: `{{tqb|\n%\n}}`
},
[`as.table`]: {
title: `Copy selected as table wikitext`,
id: `as.table`,
label: `<Table/>`,
icon: `table`,
template: ``
},
[`as.links`]: {
title: `Copy selected as raw [1]..[n] links (can be pasted into summary)`,
id: `as.links`,
label: `Links`,
icon: `wikiText`,
template: ``
},
};
static notice = {
type: 'info',
label: 'Nothing to preview. Select checkboxes!',
title: 'Info',
inline: true
}
/**
*
* @param {HTMLElement} toolbarEl - Container
* @param {Array<Object>} buttons - Arrays of buttons widgets. See add() for supported ones
* @param {Object} options -
* @param {Object} C - Context
*/
constructor(buttons, options, C) {
super();
// Options.
this.arguments = arguments;
this.arguments[1] = Object.assign({}, options || this.constructor.config);
this.arguments[2] = Object.assign({}, OO.ui, C || {});
// Toolbar widget
this.buttonsGroup = new this.arguments[2].ButtonGroupWidget({ id: this.arguments[1].id });
this.$element = this.buttonsGroup.$element;
this.$element.css(`z-index`, 2);
if (buttons) {
this.addMany(buttons);
}
}
/**
* @typedef {Object} OO.ui.ButtonWidget -
* @property {string} id -
* @method addItems
*/
/**
* Add every button to the group, associate buttons with IDs
* @example new Toolbar();
* @param {HTMLElement | OO.ui.ButtonGroupWidget | OO.ui.PopupButtonWidget} el
* @returns {Wiki.Toolbar}
*/
add(el) {
if (el == null) {
throw new this.constructor.IATE(`first argument is expected`);
}
switch (el.constructor) {
case HTMLElement:
this.buttonsGroup.$element[0].appendChild(el);
el.id && this.set(el.id, el);
break;
case this.arguments[2].ButtonWidget:
case this.arguments[2].PopupButtonWidget:
el.$element[0].id && this.set(el.$element[0].id, el);
this.buttonsGroup.addItems([el]);
break;
break;
default:
console.warn(`toolbar.add(e): unknown e.constructor.`)
}
return this;
}
/**
*
* @param {Array<HTMLElement | OO.ui.ButtonGroupWidget>} elements
* @returns
*/
addMany(elements) {
for (let i = 0; i < elements.length; i++) {
this.add(elements[i]);
}
return this;
}
toArray() {
return Array.from(this.values())
}
};
/**
* The HistoryHelper main class used as nameSpace.
* It binds provided UI elements (toolbar/revisions) and binds
* Pointer (mouse) and Keyboard strokes to actionsM
* (e.g. copy revisions to clipboard)
*/
Wiki.HH = class extends Object {
static NAME = `HistoryHelper`;
static IATE = InvalidArgumentTypeError;
// TODO: Deprecate in favor of preview copy text field
static shortcuts = {
[`ctrl+alt+d`]: `revisions.as.diffs.to.clipboard`,
[`ctrl+alt+c`]: `revisions.as.links.to.clipboard`
}
static options = {
fetchLimit: 64
}
/**
* Overview of basic HistoryHelper workflows
* ##Clipboard workflow
* revisions.keyboard -> revisionsTo…(revisions) -> clipboard.copy()
* buttons.pointer.click -> entries.to.markup -> clipboard.copy()
* buttons.pointer.hover -> buttons.popup.showPreview(revisions.as.XYZ)
* ##UX workflow
* buttons.popup.pointer -> preview.modify()
* revisions.pointer -> entries.select
* revisions.checkboxes.pointer + keyboard.shift -> entries.select
* @param {Wiki.Toolbar} revisions - Data (revisions container)
* @param {Wiki.Revisions} toolbar - Input (butttons panel)
* @param {ClipboardBuffer} clipboard - Output (clipboard buffer)
* @param {Object} options - Configuration object
* @param {Object} options.shortcuts - Shortcuts to Action map
* @param {Object} C - Namespace for default class constructors
* @param {Object} C.Revisions - Revisions entries container constructor
* @param {Object} C.Toolbar -
* @param {Object} C.Clipboard -
* @param {Object} C.Text - WikiText renderer
* used to build output strings
*/
constructor(toolbar, revisions, clipboard, options, C) {
super();
this.C = {};
this.C.Revisions = Wiki.Revisions;
this.C.Toolbar = Wiki.Toolbar; // Containers
this.C.Clipboard = ClipboardBuffer;
this.C.Text = Wiki.Text;
this.C = Object.assign(this.C, (C || {}));
this.options = Object.assign({}, this.constructor.options, options || {});
if (!(toolbar instanceof this.C.Toolbar)) throw new this.constructor.IATE(`toolbar instance of Toolbar is expected`);
if (!(revisions instanceof this.C.Revisions)) throw new this.constructor.IATE(`revisions instance of Revisions is expected`);
if (!(clipboard instanceof this.C.Clipboard)) throw new this.constructor.IATE(`clipboard instance of Clipboard is expected`);
this.toolbar = toolbar;
this.revisions = revisions;
this.clipboard = clipboard;
//#ACTIONS MAP
//------------------------------------------
// These are intended to be invoked on some user
// actions such as click or keypress
// These callbacks are called from multiple places
// DPRCT: [August 07, 2023] Remove clipboard functionality
this[`revisions.as.diffs.to.clipboard`] = function() {
this.clipboard.copy(this.constructor.revisionsToDIFFS(this.revisions.checked(), undefined, options))
}.bind(this);
this[`revisions.as.table.to.clipboard`] = function() {
this.clipboard.copy(this.constructor.revisionsToTABLE(this.revisions.checked()))
}.bind(this);
this[`revisions.as.links.to.clipboard`] = function() {
this.clipboard.copy(this.constructor.revisionsToLINKS(this.revisions.checked()))
}.bind(this);
this[`revisions.as.diffs.rendered`] = function(cb) {
let selected = this.revisions.checked().slice(0, this.options.fetchLimit);
let wikitext = this.constructor.revisionsToDIFFS(selected, undefined, options);
wikitext
? new this.C.Text(wikitext).render().done(cb)
: cb({});
}.bind(this);
this[`revisions.as.table.rendered`] = function(cb) {
let selected = this.revisions.checked().slice(0, this.options.fetchLimit);
let wikitext = this.constructor.revisionsToTABLE(selected);
wikitext
? new this.C.Text(wikitext).render().done(cb)
: cb({});
}.bind(this);
this[`revisions.as.links.rendered`] = function(cb) {
let selected = this.revisions.checked().slice(0, this.options.fetchLimit);
let wikitext = this.constructor.revisionsToLINKS(selected);
wikitext
? new this.C.Text(wikitext).render().done(cb)
: cb({});
}.bind(this);
this.buttons = this.toolbar.toArray();
this.initButtons();
this.initRevisionsListeners();
this.initRevisionsSpecialListneners();
} // CONSTRUCTOR END
// Associate button clicks with actions
initButtons() {
//#POINTER CONTROL - BUTTONS
//------------------------------------------
for (let button of this.buttons) {
button.$element.click(this[`revisions.${button.elementId}.to.clipboard`]);
// Show preview of the selected entries
button.$element.mouseenter(function(button, e) {
// Hide all popups
for (let nextButton of this.buttons) {
nextButton.popup.toggle(false);
}
button.popup.toggle(true);
let d0 = button.popup.$lable.isVisible();
if (this.revisions.isAnyChecked()) {
button.popup.$lable.toggle(false);
setTimeout(() => {
this[`revisions.${button.elementId}.rendered`]((response) => {
if (response.parse) {
button.popup.html(`${response.parse.text[`*`]}`)
} else {
button.popup.html(``);
}
});
}, 300);
} else {
button.popup.$lable.toggle(true);
}
}.bind(this, button)); // bindEventEnd
}
}
// Associate keyboard hotkeys with actions
// Only works when pointer is in area of a revisions list element
initRevisionsListeners() {
//#KEYBOARD CONTROL
//------------------------------------------
if (this.options.shortcuts) {
const ctrlKey = `ctrl`;
const shiftKey = `shift`;
const altKey = `alt`;
this.revisions.parentEl.tabIndex = 1;
$(this.revisions.parentEl).bind(`keyup`, (e) => {
let pressedKeys = ``;
pressedKeys += e.ctrlKey ? ctrlKey + `+` : ``;
pressedKeys += e.shiftKey ? shiftKey + `+` : ``;
pressedKeys += e.altKey ? altKey + `+` : ``;
pressedKeys += e.key;
// Match the keystroke into a an action declared above
let action = this[this.options.shortcuts[pressedKeys]];
if (action) action();
});
}
}
// Associate keyboard + pointer hotkeys behavior
// Allows selecting checkboxes range by using shift + checkbox click
initRevisionsSpecialListneners() {
//#CHECKBOXES CONTROL
//------------------------------------------
this.revisions.checkboxes.lastClicked[1] = this.revisions.checkboxes[0];
$(this.revisions.el).click((e) => {
// Clear up preview data
for (let button of this.buttons) {
button.popup.html(``);
}
// We need to focuse only on widget's span element
let focusedCheckbox;
if (e.target instanceof HTMLInputElement) {
focusedCheckbox = e.target.parentElement;
}
if (e.target instanceof HTMLSpanElement
&& /oo-ui-checkboxInputWidget/.test(e.target.className)) {
focusedCheckbox = e.target;
}
/**@type Array<CheckboxInputWidgets> */
let checkboxes = this.revisions.checkboxes;
if (checkboxes.lastClicked[1] !== focusedCheckbox) {
checkboxes.lastClicked[0] = checkboxes.lastClicked[1];
checkboxes.lastClicked[1] = focusedCheckbox;
}
if (
e.shiftKey &&
checkboxes.lastClicked[0] &&
checkboxes.lastClicked[1]
) {
let from = checkboxes.findIndex((widget) => {
return checkboxes.lastClicked[0] === widget.$element[0]
});
let to = checkboxes.findIndex((widget) => {
return checkboxes.lastClicked[1] === widget.$element[0]
});
if (from > to) {
let mid = to;
to = from;
from = mid;
}
from++;
for (; from < to; from++) {
checkboxes[from].setSelected(!checkboxes[from].isSelected())
}
}
});
}
// Words to higlight
static highlights = /competen(t|cy)|IR|bitch|illiterate|fuck(er)?|asshole(ery)?|troll|idiot|dumbass|stupid|blank|subhuman|autis[tm]|(edit)? warring|inept/g;
/** Convert revisions entries into a Wikitext (diffs)
* @since 2.6.0
* @param {Wiki.Revisions} revisions - Array that contains Entry instances
* @param {Wiki.Text.Tag} Tag
* @returns {String}
*/
static revisionsToDIFFS(revisions, Tag, config) {
Tag = Tag || Wiki.Text.Tag;
if (!(revisions)) { throw new this.IATE(`Revisions are missing`) }
if (!revisions.length) { return `` }
let entry, tag, wikitext = ``;
let comment;
let users = new Set();
// Walk over every entry
for (let i = 0; i < revisions.length; i++) {
entry = revisions[i];
if (entry && new Object(entry.user).constructor == String) {
if (entry.user !== mw.config.get(`wgUserName`)) {
users.add(entry.user);
}
}
if (entry && new Object(entry.date).constructor == Wiki.Date) {
entry.date = entry.date.format();
}
tag = new Tag(`diff`, [
entry.diff,
entry.oldid,
entry.date,
]);
// Highlight specified by config words and phrases
// Highlight incivility
comment = entry.comment.replace(this.highlights, `{{highlight|$&}}`);
let highlights = config && new Object(config.highlights);
if (highlights
&& highlights.constructor === Array
&& highlights.length) {
for (let i = 0, reg; i < highlights.length; i++) {
reg = highlights[i];
comment = comment.replace(reg, `{{highlight|$&}}`);
}
}
comment = comment ? `- ''«${comment}»''` : ``;
wikitext += `${tag.toString()} ${comment}<br/>\n`;
}
if (users.size) {
wikitext += ':';
wikitext += new Tag(`re`, Array.from(users));
}
return wikitext
}
/** Convert revisions entries into a Wikitext (Special:Diff/… links)
* @since 2.6.0
* @param {Wiki.Revisions} revisions - Array that contains Entry instances
* @returns {String}
*/
static revisionsToLINKS(revisions) {
if (!(revisions)) { throw new this.IATE(`Revisions are missing`) }
if (!revisions.length) { return `No revisions selected` }
let entry, wikitext = ``;
for (let i = 0; i < revisions.length; i++) {
entry = revisions[i];
if (entry && new Object(entry.date).constructor == Wiki.Date) {
entry.date = entry.date.format();
}
// Omit prev
let diff = entry.oldid;
if(diff == "prev") {
diff = entry.diff
}
wikitext += `[[Special:Diff/${diff}|[${entry.date}]]]`
}
return wikitext
}
/** Convert revisions entries into a Wikitext (tables )
* @since 2.6.0
* @param {Wiki.Revisions} revisions - Array that contains Entry instances
* @param {Wiki.Text.Tag} Tag
* @param {Wiki.Text.Table} Table
* @returns {String}
*/
static revisionsToTABLE(revisions, Tag, Table) {
if (!(revisions)) { throw new this.IATE(`Revisions are missing`) }
if (!revisions.length) { return `` }
Table = Table || Wiki.Text.Table;
Tag = Tag || Wiki.Text.Tag;
// Every entry wrapped into a wiki tag
// Group of tags into table definitions (colums)
let entry;
let anchor, anchLink, diff, oldid, user, tags, entries;
let defintions = [];
for (let i = 0; i < revisions.length; i++) {
entry = revisions[i];
anchLink = `hist-${i}-${entry.diff}`;
anchor = new Tag(`anchor`, [anchLink]);
diff = new Tag(`diff`, [entry.oldid, entry.date]);
oldid = new Tag(`oldid2`, [1, entry.oldid, entry.date]);
user = new Tag(`u`, [entry.user]);
tags = [
anchor + `[[#${anchLink}|${i}]]`,
diff,
oldid,
user,
entry.comment ? `''${entry.comment}''` : ``
]
defintions.push(tags.map(tag => new Table.Def(tag)));
}
// Wrap ever column into a row
// First row is the head
let columns;
let rows = [
new Table.Header({
arr: [`#`, `DIFF`, `CURRENT`, `USER`, `SUMMARY`],
})
];
for (let i = 0; i < defintions.length; i++) {
columns = defintions[i];
rows.push(new Table.Row({ arr: columns }))
}
let wikitext = new Table({
cssClasses: "wikitable sortable",
rows: rows,
}).toString();
return wikitext;
}
};
//#USER CONFIG
//------------------------------------------
// Convert legacy (prior 2.6.0) config version into a 2.6.0
if (window.HistoryHelper && window.HistoryHelper.shortcuts) {
let shortcuts = window.HistoryHelper.shortcuts;
// 1/2 For every shortcut
for (const key in shortcuts) {
if (Object.hasOwnProperty.call(shortcuts, key)) {
const actionName = shortcuts[key];
// 2/2 if an old action match, replace by a new one
if (actionName === `copyAsdiffs`) {
shortcuts[key] = `revisions.as.links.to.clipboard`;
console.warn(`${Wiki.HH.NAME}: copyAsdiffs action is deprecated after v2.6.0, update your config`)
}
}
}
}
let config = Object.assign(
{}
// Turn off default shortcuts
// ,{ shortcuts: Wiki.HH.shortcuts},
, window.HistoryHelper || {}
);
// ---------------------------------------------------------------------------
// #MAIN
// ---------------------------------------------------------------------------
let main = function main() {
let contribPageRe = /Special:Contributions/
let isContributionsPage = contribPageRe.test(window.location.href);
let isHistoryPage = new URL(window.location).searchParams.get("action") == "history";
if (!(isContributionsPage || isHistoryPage)) {
return
}
// Initialize toolbar & buttons
let buttons = Object.values(Wiki.Toolbar.buttons).map((data) => {
let $lable = new OO.ui.MessageWidget(Wiki.Toolbar.notice);
$lable.$element.css(`min-width`, `478px`)
let $content = $(`<div></div>`)
// .append($notice.$element);
let popup = new OO.ui.PopupWidget({
width: null,
head: true,
label: $lable.$element,
$content: $content,
padded: true,
autoClose: true,
autoFlip: false
});
popup.$element.css(`z-index`, 32);
popup.$element.css(`min-width`, `330px`);
popup.$element.css(`min-height`, `127px`);
popup.$content = $content;
popup.$lable = $lable;
popup.html = function(str) {
return this.$content.html(str)
}
let button = new OO.ui.ButtonWidget({ ...data, content: [popup] });
button.popup = popup;
return button
})
// New toolbar
window[Wiki.Toolbar.config.id] && window[Wiki.Toolbar.config.id].remove();
let toolbar = new Wiki.Toolbar(buttons);
// Initialize revisions container
let pagehistory = document.getElementById(`pagehistory`)
|| document.querySelector(`#mw-content-text section.mw-pager-body`);
if (!(pagehistory)) {
throw new Error(
`${Wiki.HH.NAME}: can't find revisions html element.
\n\tThis is probably due to Wikipedia changing its HTML ids.
\n\tContact the script author for help:
\n\thttps://en.wikipedia.org/w/index.php?title=User_talk:Alexander_Davronov&action=edit§ion=new`
);
return
}
// Remove old checkboxes
Wiki.Revisions2.checkboxesCleanUp(pagehistory);
let clipboard = new ClipboardBuffer();
// Article or User history page
// https://www.mediawiki.org/wiki/Manual:Interface/JavaScript#mw.config
if (isHistoryPage) {
let rawRevisions = Array.from(pagehistory.querySelectorAll(`ul > li`));
let revisions = Wiki.Revisions2.fromEl(
rawRevisions, {}, {}
, Wiki.Revisions2.EntryCB
);
// Adding tools
let revCompareForm = document.getElementById(`mw-history-compare`);
let toolbarContainerTarget =
revCompareForm
&& revCompareForm.querySelector(`.mw-history-compareselectedversions`);
$(toolbarContainerTarget).append(toolbar.$element);
if (toolbar.$element[0] && !toolbar.$element[0].children.length) {
throw new Error(`${Wiki.HH.NAME}: Toolbar has no buttons, please fill a bug report!`);
}
// Init HistoryHelper controls (button press handlers)
// over toolbar and revisions
new Wiki.HH(toolbar, revisions, clipboard, config);
return
}
// User contributions page
let isViewing = mw.config.get(`wgAction`) === `view`;
if (isViewing) {
let rawRevisions = Array.from(pagehistory.querySelectorAll(`ul > li`));
let revisions = Wiki.Contributions.fromEl(
rawRevisions, {}, {}
, Wiki.Contributions.EntryCB
, { user: mw.config.get(`wgRelevantUserName`) }
);
let toolbarContainerTarget = document.getElementById(`mw-content-text`).firstChild;
toolbar.$element.insertAfter(toolbarContainerTarget);
new Wiki.HH(toolbar, revisions, clipboard, config);
return
}
}
mw.loader.using([`oojs-ui.styles.icons-editing-advanced`, `oojs-ui.styles.icons-alerts`], main);
// From the End comes The Beginning!
// Something ends, something begins!
});
