MediaWiki:Gadget-morebits.js: Difference between revisions

(function() {

const Morebits = {};

window.Morebits = Morebits; // allow global access

* Morebits.i18n.setParser({ get: $.i18n });

* var banana = new Banana('en');

* Morebits.i18n.setParser({ get: banana.i18n });

* @return {string}

const args = Array.prototype.slice.call(arguments); // array of size `n`

const msgName = args[0];

const fallback = args[args.length - 1];

const i18nMessage = Morebits.i18n.parser.get.apply(null, args.slice(0, -1));

const msg = Morebits.i18n.getMessage;

* @return {number[] | null}

const rgx = /(\d{2}):(\d{2}), (\d{1,2}) (\w+) (\d{4}) \(UTC\)/;

const match = rgx.exec(str);

const month = Morebits.date.localeData.months.indexOf(match[4]);

  * @return {boolean}

return mw.config.get('wgUserGroups').includes(group);

/**

* Hardcodes whether the user is a sysop, used a lot.

  * @return {string}

  * @return {boolean}

  * @return {string} - For a page name `Foo bar`, returns the string `[Ff]oo[_ ]bar`.

const firstChar = pageName[0],

  * @return {DocumentFragment}

const fragment = document.createDocumentFragment();

for (let i = 0; i < input.length; ++i) {

$.parseHTML(Morebits.createHtml.renderWikilinks(input[i])).forEach((node) => {

  * @return {*}

const ub = new Morebits.unbinder(text);

(_, target, text) => {

  * @return {string} - Regex-suitable string of all namespace aliases.

const aliases = [];

let regex;

$.each(mw.config.get('wgNamespaceIds'), (name, number) => {

if (namespaces.includes(number)) {

aliases.push(name.split('').map((char) => Morebits.pageNameRegex(char)).join(''));

  * @return {HTMLElement}

const ret = this.root.render();

  * @return {Morebits.quickForm.element} - Same as what is passed to the function.

  *      - Attributes: name, label, min, max, inputs, sublabel, value, size, maxlength, event

  * - `option`, `optgroup`, `_dyninput_cell`, `submit`, and `button` accept only a single string.

  * @param {Object} data - Object representing the quickform element. Should

  * @return {Morebits.quickForm.element} The same element passed in.

let child;

  * @return {HTMLElement}

const currentNode = this.compute(this.data, internal_subgroup_id);

for (let i = 0; i < this.childs.length; ++i) {

let node;

let childContainer = null;

let label;

const id = (in_id ? in_id + '_' : '') + 'node_' + Morebits.quickForm.element.id++;

let i, current, subnode;

const cur_id = id + '_' + i;

// inline hack

let tmpgroup = current.subgroup;

$.each(tmpgroup, (idx, el) => {

const newEl = $.extend({}, el);

const subgroup = subgroupRaw.render(cur_id);

const name = e.target.name;

const name = e.target.name;

['min', 'max', 'step', 'list'].forEach((att) => {

['value', 'size', 'placeholder', 'maxlength'].forEach((att) => {

['disabled', 'required', 'readonly'].forEach((att) => {

const new_node = new Morebits.quickForm.element(e.target.sublist);

type: '_dyninput_row',

event: data.event,

const elem = new Morebits.quickForm.element(sublist);

case '_dyninput_row': // Private

label.setAttribute('for', id + '_input');

node.style.marginRight = '3px';

break;

case 'hidden':

node = document.createElement('input');

node.setAttribute('type', 'hidden');

const result = document.createElement('span');

const labelElement = document.createElement('label');

  * @requires jQuery.ui

  * @param {Object} data - Tooltip-related configuration data.

const tooltipButton = node.appendChild(document.createElement('span'));

  * @return {Object} With field names as keys, input data as values.

const result = {};

for (let i = 0; i < form.elements.length; i++) {

const field = form.elements[i];

const fieldNameNorm = field.name.slice(field.name.indexOf('.') + 1);

if (field.dataset.dyninput) {

result[fieldNameNorm] = field.value.trim();

  * @return {HTMLElement[]} - Array of matching form elements.

const $form = $(form);

let $elements = $form.find('[name="' + fieldName + '"]');

  * @return {HTMLInputElement}

const found = $.grep(elementArray, (el) => el.value === value);

  * @return {HTMLElement}

element instanceof HTMLHeadingElement) {

  * @return {HTMLElement}

element instanceof HTMLDivElement || element instanceof HTMLHeadingElement) {

// for fieldsets, the label is the child <legend> element

// for textareas, the label is the sibling <h5> element

  * @return {string}

const labelElement = Morebits.quickForm.getElementLabelObject(element);

  * @return {boolean} True if succeeded, false if the label element is unavailable.

const labelElement = Morebits.quickForm.getElementLabelObject(element);

  * @return {boolean} `true` if succeeded, `false` if the label element is unavailable.

  * @return {boolean} True if succeeded, false if the label element is unavailable.

  * @method external:HTMLFormElement.getChecked

  * @return {string[]} - Contains the values of elements with the given name

const elements = this.elements[name];

const return_array = [];

let i;

const options = elements.options;

  * @method external:HTMLFormElement.getUnchecked

  * @return {string[]} - Contains the values of elements with the given name

const elements = this.elements[name];

const return_array = [];

let i;

const options = elements.options;

* @return {string}

const abbrevPos = address.indexOf('::');

const CIDRStart = address.indexOf('/');

const addressEnd = CIDRStart !== -1 ? CIDRStart - 1 : address.length - 1;

let repeat, extra, pad;

let replacement = repeat;

for (let i = 1; i < pad; i++) {

* @return {boolean} - True if given a valid IP address range, false otherwise.

* @return {boolean} - True for valid ranges within the CIDR limits,

const subnet = parseInt(ip.match(/\/(\d{1,3})$/)[1], 10);

* @return {boolean|string} - False if not IPv6 or bigger than a 64,

const subnetMatch = ipv6.match(/\/(\d{1,3})$/);

const ip_re = /^((?:[0-9A-F]{1,4}:){4})(?:[0-9A-F]{1,4}:){3}[0-9A-F]{1,4}(?:\/\d{1,3})?$/;

* @return {string}

return str.slice(0, 1).toUpperCase() + str.slice(1);

* @return {string}

return str.slice(0, 1).toLowerCase() + str.slice(1);

* @return {string[]}

let level = 0;

let initial = null;

const result = [];

for (let i = 0; i < str.length; ++i) {

for (let j = 0; j < skiplist.length; ++j) {

* @return {string}

let reason = (str || '').toString().trim();

const unbinder = new Morebits.unbinder(reason);

const sig = '~~~~', sigIndex = reason.lastIndexOf(sig);

* @return {string}

* @return {string}

* @return {boolean}

return ['indefinite', 'infinity', 'infinite', 'never'].includes(expiry);

* @return {string} - The escaped text.

* @return {Array} A copy of the array with duplicates removed.

throw new Error('A non-array object passed to Morebits.array.uniq');

return arr.filter((item, idx) => arr.indexOf(item) === idx);

* @return {Array} A copy of the array with the first instance of each value

throw new Error('A non-array object passed to Morebits.array.dups');

return arr.filter((item, idx) => arr.indexOf(item) !== idx);

* @return {Array[]} An array containing the smaller, chunked arrays.

throw new Error('A non-array object passed to Morebits.array.chunk');

const numChunks = Math.ceil(arr.length / size);

const result = new Array(numChunks);

for (let i = 0; i < numChunks; i++) {

  * @requires jQuery.select2

const originalMatcher = $.fn.select2.defaults.defaults.matcher;

const result = originalMatcher(params, data);

data.text.toUpperCase().includes(params.term.toUpperCase())) {

const originalMatcher = $.fn.select2.defaults.defaults.matcher;

const result = originalMatcher(params, data);

const searchTerm = Morebits.select2SearchQuery;

const idx = data.text.toUpperCase().indexOf(searchTerm.toUpperCase());

let $target = $(ev.target).closest('.select2-container');

if (!$target.length) {

$target = $target.prev();

$target.select2('open');

const search = $target.data('select2').dropdown.$search ||

$target.data('select2').selection.$search;

search[0].focus();

const re = new RegExp(prefix + '([\\s\\S]*?)' + postfix, 'g');

* @return {string} The processed output.

let content = this.content;

for (const current in this.history) {

const current = self.prefix + self.counter + self.postfix;

const args = Array.prototype.slice.call(arguments);

const param = args[0];

const digitMatch = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(param);

this.privateDate = new Date(Date.UTC.apply(null, [digitMatch[1], digitMatch[2] - 1, digitMatch[3], digitMatch[4], digitMatch[5], digitMatch[6]]));

const dateParts = Morebits.l10n.signatureTimestampFormat(param);

this.privateDate = new Date(Date.UTC.apply(null, dateParts));

if (!this.privateDate) {

this.privateDate = new (Function.prototype.bind.apply(Date, [Date].concat(args)))();

/** @return {boolean} */

* @return {boolean}

* @return {boolean}

/** @return {string} */

/** @return {string} */

/** @return {string} */

/** @return {string} */

/** @return {string} */

/** @return {string} */

/** @return {string} */

/** @return {string} */

* @return {Morebits.date}

let num = parseInt(number, 10); // normalize

const unitMap = Morebits.date.unitMap;

let unitNorm = unitMap[unit] || unitMap[unit + 's']; // so that both singular and  plural forms work

unitNorm = 'Date';

num *= 7;

* @return {Morebits.date}

* @return {string}

let udate = this;

const pad = function(num, len) {

const h24 = udate.getHours(), m = udate.getMinutes(), s = udate.getSeconds(), ms = udate.getMilliseconds();

const D = udate.getDate(), M = udate.getMonth() + 1, Y = udate.getFullYear();

const h12 = h24 % 12 || 12, amOrPm = h24 >= 12 ? msg('period-pm', 'PM') : msg('period-am', 'AM');

const replacementMap = {

const unbinder = new Morebits.unbinder(formatstr); // escape stuff between [...]

* d(d{2,3})? matches exactly 1, 3 or 4 occurrences of 'd' ('dd' is treated as a double match of 'd')

* Y{1,2}(Y{2})? matches exactly 1, 2 or 4 occurrences of 'Y'

*/

(match) => replacementMap[match]

* @return {string}

const dateDiff = (new Date().setHours(0, 0, 0, 0) -

* @return {RegExp}

* @return {string}

const header = '='.repeat(level);

const text = this.getUTCMonthName() + ' ' + this.getUTCFullYear();

Object.getOwnPropertyNames(Date.prototype).forEach((func) => {

Morebits.date.prototype[func] = function() {

return this.privateDate[func].apply(this.privateDate, Array.prototype.slice.call(arguments));

};

  * Various objects for wiki editing and API access, including

  * {@link Morebits.wiki.api} and {@link Morebits.wiki.page}.

  * @return {boolean}