wikiplus-highlight 2.7.1

package/matchtags.js

@@ -0,0 +1,308 @@
+/*
+ * CodeMirror, copyright (c) by Marijn Haverbeke and others
+ * Distributed under an MIT license: https://codemirror.net/LICENSE
+ * Modified for MediaWiki by Bhsd <https://github.com/bhsd-harry>
+ */
+
+(() => {
+	'use strict';
+
+	const {Pos, cmpPos} = CodeMirror;
+
+	const tagStart = /<(\/?)([A-Z_a-z]\w*)/g,
+		voidTags = ['br', 'wbr', 'hr', 'img'];
+
+	class Iter {
+		constructor(cm, pos) {
+			const {line, ch} = pos,
+				{state: {matchTags: {maxScanLines = 1000}}} = cm;
+			this.line = line;
+			this.ch = ch;
+			this.cm = cm;
+			this.text = cm.getLine(line);
+			this.min = Math.max(line - maxScanLines + 1, cm.firstLine());
+			this.max = Math.min(line + maxScanLines - 1, cm.lastLine());
+		}
+
+		isTag() {
+			const type = this.cm.getTokenTypeAt(Pos(this.line, this.ch));
+			return /\b(?:mw-(?:html|ext)tag|tag\b)/.test(type);
+		}
+
+		bracketAt(ch) {
+			const type = this.cm.getTokenTypeAt(Pos(this.line, ch + 1));
+			return /\b(?:mw-(?:html|ext)tag-)?bracket\b/.test(type);
+		}
+
+		// Jump to the start of the next line
+		nextLine() {
+			if (this.line >= this.max) {
+				return;
+			}
+			this.ch = 0;
+			this.text = this.cm.getLine(++this.line);
+			return true;
+		}
+
+		// Jump to the end of the previous line
+		prevLine() {
+			if (this.line <= this.min) {
+				return;
+			}
+			this.text = this.cm.getLine(--this.line);
+			this.ch = this.text.length;
+			return true;
+		}
+
+		// Jump to the letter after a '>' towards the line end
+		toTagEnd() {
+			for (;;) {
+				const gt = this.text.indexOf('>', this.ch);
+				if (gt === -1) {
+					return;
+				}
+				if (!this.bracketAt(gt)) {
+					this.ch = gt + 1;
+					continue;
+				}
+				const lastSlash = this.text.lastIndexOf('/', gt);
+				const selfClose = lastSlash > -1 && !/\S/.test(this.text.slice(lastSlash + 1, gt));
+				this.ch = gt + 1;
+				return selfClose ? 'selfClose' : 'regular';
+			}
+		}
+
+		// Jump to a '<' towards the line start
+		toTagStart() {
+			for (;;) {
+				const lt = this.ch ? this.text.lastIndexOf('<', this.ch - 1) : -1;
+				if (lt === -1) {
+					return;
+				}
+				if (!this.bracketAt(lt)) {
+					this.ch = lt;
+					continue;
+				}
+				tagStart.lastIndex = lt;
+				this.ch = lt;
+				const match = tagStart.exec(this.text);
+				if (match && match.index === lt) {
+					return match;
+				}
+			}
+		}
+
+		// Jump to the start of the last line, or the letter after a ${tagStart}
+		toNextTag() {
+			for (;;) {
+				tagStart.lastIndex = this.ch;
+				const found = tagStart.exec(this.text);
+				if (!found) {
+					if (this.nextLine()) {
+						continue;
+					} else {
+						return;
+					}
+				}
+				if (!this.bracketAt(found.index)) {
+					this.ch = found.index + found[0].length;
+					continue;
+				}
+				this.ch = found.index + found[0].length;
+				return found;
+			}
+		}
+
+		// Jump to the end of the first line, or a non-bracket '>', or the letter after a tag bracket '>'
+		toPrevTag() {
+			for (;;) {
+				const gt = this.ch ? this.text.lastIndexOf('>', this.ch - 1) : -1;
+				if (gt === -1) {
+					if (this.prevLine()) {
+						continue;
+					} else {
+						return;
+					}
+				}
+				if (!this.bracketAt(gt)) {
+					this.ch = gt;
+					continue;
+				}
+				const lastSlash = this.text.lastIndexOf('/', gt);
+				const selfClose = lastSlash > -1 && !/\S/.test(this.text.slice(lastSlash + 1, gt));
+				this.ch = gt + 1;
+				return selfClose ? 'selfClose' : 'regular';
+			}
+		}
+
+		findMatchingClose(tag) {
+			const stack = [];
+			for (;;) {
+				const next = this.toNextTag();
+				if (!next) {
+					return;
+				}
+				const start = this.ch - next[0].length,
+					end = this.toTagEnd(),
+					tagName = next[2].toLowerCase();
+				if (!end) {
+					return;
+				}
+				if (end === 'selfClose' || voidTags.includes(tagName)) {
+					continue;
+				}
+				if (next[1]) { // closing tag
+					let i = stack.length - 1;
+					for (; i >= 0; --i) {
+						if (stack[i] === tagName) {
+							stack.length = i;
+							break;
+						}
+					}
+					if (i < 0 && (!tag || tag === tagName)) {
+						return {
+							tag: tagName,
+							from: Pos(this.line, start),
+							to: Pos(this.line, this.ch),
+						};
+					}
+				} else { // opening tag
+					stack.push(tagName);
+				}
+			}
+		}
+
+		findMatchingOpen(tag) {
+			const stack = [];
+			for (;;) {
+				const prev = this.toPrevTag();
+				if (!prev) {
+					return;
+				}
+				const end = this.ch,
+					start = this.toTagStart();
+				if (!start) {
+					return;
+				}
+				const tagName = start[2].toLowerCase();
+				if (prev === 'selfClose' || voidTags.includes(tagName)) {
+					continue;
+				}
+				if (start[1]) { // closing tag
+					stack.push(tagName);
+				} else { // opening tag
+					let i = stack.length - 1;
+					for (; i >= 0; --i) {
+						if (stack[i] === tagName) {
+							stack.length = i;
+							break;
+						}
+					}
+					if (i < 0 && (!tag || tag === tagName)) {
+						return {
+							tag: tagName,
+							from: Pos(this.line, this.ch),
+							to: Pos(this.line, end),
+						};
+					}
+				}
+			}
+		}
+	}
+
+	CodeMirror.defineExtension('findMatchingTag', function(pos) {
+		let iter = new Iter(this, pos);
+		if (!iter.isTag()) {
+			return;
+		}
+		const end = iter.toTagEnd(),
+			to = end && Pos(iter.line, iter.ch);
+		const start = end && iter.toTagStart();
+		if (!start || cmpPos(iter, pos) > 0) {
+			return;
+		}
+		const tag = start[2].toLowerCase(),
+			here = {from: Pos(iter.line, iter.ch), to, tag};
+		if (end === 'selfClose' || voidTags.includes(tag)) {
+			return {open: here, close: null, at: 'self'};
+		}
+
+		if (start[1]) { // closing tag
+			return {open: iter.findMatchingOpen(tag), close: here, at: 'close'};
+		} // opening tag
+		iter = new Iter(this, to);
+		return {open: here, close: iter.findMatchingClose(tag), at: 'open'};
+	});
+
+	CodeMirror.defineExtension('findEnclosingTag', function(pos, tag) {
+		const iter = new Iter(this, pos);
+		const open = iter.findMatchingOpen(tag);
+		if (!open) {
+			return;
+		}
+		const forward = new Iter(this, pos);
+		const close = forward.findMatchingClose(open.tag);
+		if (close) {
+			return {open, close};
+		}
+	});
+
+	// Used by addon/edit/closetag.js
+	CodeMirror.scanForClosingTag = function(cm, pos, name) {
+		const iter = new Iter(cm, pos);
+		return iter.findMatchingClose(name);
+	};
+
+	CodeMirror.defineOption('matchTags', false, (cm, val, old) => {
+		if (old && old !== CodeMirror.Init) {
+			cm.off('cursorActivity', doMatchTags);
+			clear(cm);
+		}
+		if (val) {
+			cm.state.matchTags = typeof val === 'object' ? val : {};
+			cm.on('cursorActivity', doMatchTags);
+			doMatchTags(cm);
+		}
+	});
+
+	function clear(cm) {
+		if (cm.state.tagHit) {
+			cm.state.tagHit.clear();
+		}
+		if (cm.state.tagOther) {
+			cm.state.tagOther.clear();
+		}
+		cm.state.tagHit = null;
+		cm.state.tagOther = null;
+	}
+
+	function doMatchTags(cm) {
+		cm.operation(() => {
+			clear(cm);
+			if (cm.somethingSelected()) {
+				return;
+			}
+			const match = cm.findMatchingTag(cm.getCursor());
+			if (!match) {
+				return;
+			}
+			if (match.at === 'self') {
+				cm.state.tagHit = cm.markText(match.open.from, match.open.to, {className: 'cm-matchingtag'});
+				return;
+			}
+			const hit = match.at === 'open' ? match.open : match.close,
+				other = match.at === 'close' ? match.open : match.close;
+			if (hit) {
+				cm.state.tagHit = cm.markText(hit.from, hit.to, {className: `cm-${other ? '' : 'non'}matchingtag`});
+			}
+			if (other) {
+				cm.state.tagOther = cm.markText(other.from, other.to, {className: 'cm-matchingtag'});
+			}
+		});
+	}
+
+	mw.loader.addStyleTag(
+		'.cm-matchingtag{background-color:#c9ffc8}'
+		+ '.cm-nonmatchingtag{background-color:#fff0a8}',
+	);
+})();

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "wikiplus-highlight",
+  "version": "2.7.1",
+  "description": "A plugin for the MediaWiki front-end add-on \"Wikiplus\"",
+  "main": "main.js",
+  "scripts": {
+    "test": "echo 'Error: no test specified' && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bhsd-harry/Wikiplus-highlight.git"
+  },
+  "keywords": [
+    "mediawiki",
+    "mediawiki-gadget",
+    "wikiplus"
+  ],
+  "author": "Bhsd",
+  "license": "GPL-3.0",
+  "bugs": {
+    "url": "https://github.com/bhsd-harry/Wikiplus-highlight/issues"
+  },
+  "homepage": "https://github.com/bhsd-harry/Wikiplus-highlight#readme"
+}

package/search.js

@@ -0,0 +1,187 @@
+/**
+ * @author Bhsd <https://github.com/bhsd-harry>
+ * @license: GPL-3.0
+ */
+
+(() => {
+	'use strict';
+
+	const msg = key => mw.msg(`wphl-${key}`);
+
+	// Prepare elements
+	const $search = $('<input>', {
+			id: 'Wikiplus-Quickedit-Search',
+			placeholder: msg('search-placeholder'),
+		}),
+		$searchClose = $('<span>', {
+			text: '×',
+			id: 'Wikiplus-Quickedit-Search-Close',
+			class: 'Wikiplus-Symbol-Btn',
+		}),
+		$searchNext = $('<span>', {
+			text: '▼',
+			id: 'Wikiplus-Quickedit-Search-Next',
+			class: 'Wikiplus-Symbol-Btn',
+		}),
+		$searchPrev = $('<span>', {
+			text: '▲',
+			id: 'Wikiplus-Quickedit-Search-Prev',
+			class: 'Wikiplus-Symbol-Btn',
+		}),
+		$searchContainer = $('<div>', {
+			id: 'Wikiplus-Quickedit-Search-Div',
+			html: [
+				$search,
+				$searchNext,
+				$searchPrev,
+				$searchClose,
+			],
+		}),
+		$searchBtn = $('<span>', {
+			class: 'Wikiplus-Btn',
+			text: msg('addon-search'),
+		});
+
+	const escapeRegExp = mw.util.escapeRegExp || mw.RegExp.escape; // @type {(function|undefined)}
+	const overlay = {token: () => {}};
+
+	/**
+	 * 根据搜索字符串生成高亮
+	 */
+	const token = str => {
+		let initial;
+		if (typeof str === 'string') {
+			initial = RegExp(`[^${escapeRegExp(str[0])}]`, 'i');
+		}
+		return stream => {
+			if (stream.match(str, true, true)) {
+				return 'search';
+			}
+			stream.next();
+			if (typeof str === 'string') {
+				stream.eatWhile(initial);
+			}
+		};
+	};
+
+	// input event handler of $search
+	const onInput = () => {
+		$search.css('background-color', '').off('input', onInput);
+	};
+
+	// keyboard event handler of $search
+	let lastPtn, cursor;
+	const findNext = (cm, dir) => {
+		let ptn = $search.val();
+		if (!ptn) {
+			return;
+		}
+
+		if (/^\/.+\/i?$/.test(ptn)) {
+			ptn = ptn.endsWith('i')
+				? RegExp(ptn.slice(1, -2), 'i')
+				: RegExp(ptn.slice(1, -1));
+		}
+		if (ptn !== lastPtn) {
+			cm.removeOverlay(overlay);
+			overlay.token = token(ptn);
+			cm.addOverlay(overlay);
+			lastPtn = ptn;
+			cursor = cm.getSearchCursor(ptn, cm.getCursor(), {caseFold: true});
+		}
+		const method = dir ? 'findNext' : 'findPrevious';
+		let result = cursor[method]();
+		if (!result) {
+			if (dir) {
+				cursor = cm.getSearchCursor(ptn, {line: 0, ch: 0}, {caseFold: true});
+			} else {
+				const lastLine = cm.lastLine(),
+					lastCh = cm.getLine(lastLine).length;
+				cursor = cm.getSearchCursor(ptn, {line: lastLine, ch: lastCh}, {caseFold: true});
+			}
+			result = cursor[method]();
+		}
+		if (result) {
+			const from = cursor.from(),
+				to = cursor.to();
+			cm.setSelection(from, to);
+			cm.scrollIntoView({from, to});
+			onInput();
+		} else {
+			$search.css('background-color', 'pink').on('input', onInput);
+		}
+	};
+
+	// click event handler of $searchBtn
+	const findNew = () => {
+		$searchContainer.show();
+		$search.select().focus()[0]
+			.scrollIntoView({behavior: 'smooth'});
+	};
+
+	// click event handler of $searchClose
+	const reset = cm => {
+		cm.removeOverlay(overlay);
+		$searchContainer.hide();
+		lastPtn = '';
+	};
+
+	CodeMirror.commands.findForward = doc => {
+		findNext(doc, true);
+	};
+	CodeMirror.commands.findBackward = doc => {
+		findNext(doc, false);
+	};
+
+	const {name} = $.client.profile(),
+		focus = name === 'safari'
+			? cm => {
+				cm.focus();
+			}
+			: () => {};
+	mw.hook('wiki-codemirror').add(cm => {
+		const $textarea = $(cm.getWrapperElement()).prev('#Wikiplus-Quickedit');
+		if ($textarea.length === 0) {
+			return;
+		}
+		$searchContainer.hide().insertBefore($textarea);
+		$searchBtn.click(findNew).insertAfter('#Wikiplus-Quickedit-Jump');
+		$searchClose.click(() => {
+			reset(cm);
+		});
+		$searchNext.click(() => {
+			findNext(cm, true);
+			focus(cm);
+		});
+		$searchPrev.click(() => {
+			findNext(cm, false);
+			focus(cm);
+		});
+		$search.val('').keydown(e => {
+			if (e.key === 'Enter') {
+				e.preventDefault();
+				findNext(cm, true);
+				focus(cm);
+			} else if (e.key === 'Escape') {
+				e.stopPropagation();
+				reset(cm);
+			}
+		});
+		cm.addKeyMap({
+			'Ctrl-F': findNew,
+			'Cmd-F': findNew,
+			'Ctrl-G': 'findForward',
+			'Cmd-G': 'findForward',
+			'Shift-Ctrl-G': 'findBackward',
+			'Shift-Cmd-G': 'findBackward',
+		});
+	});
+
+	mw.loader.addStyleTag(
+		'.Wikiplus-Btn{line-height:1.4}'
+		+ '#Wikiplus-Quickedit-Search-Div{margin:7px 0 5px;}'
+		+ '.Wikiplus-Symbol-Btn{font-size:20px;margin:7px;vertical-align:middle;cursor:pointer;}'
+		+ '#Wikiplus-Quickedit-Search{width:50%;}'
+		+ 'span.cm-search{background-color:#ffc0cb83;}',
+	);
+})();