@@ -26,8 +26,9 @@
diff --git a/special/recentchanges/Makefile b/special/recentchanges/Makefile
new file mode 100644
index 0000000..1b03c31
--- /dev/null
+++ b/special/recentchanges/Makefile
@@ -0,0 +1,6 @@
+
+all: dist/app.js
+
+dist/app.js: src/*.js
+ # node_modules/.bin/rollup src/index.js --file dist/index.js --format iife
+ node_modules/.bin/rollup -c
diff --git a/special/recentchanges/dist/recentchanges.js b/special/recentchanges/dist/recentchanges.js
new file mode 100644
index 0000000..92182dc
--- /dev/null
+++ b/special/recentchanges/dist/recentchanges.js
@@ -0,0 +1,915 @@
+(function () {
+ 'use strict';
+
+ var xhtml = "http://www.w3.org/1999/xhtml";
+
+ var namespaces = {
+ svg: "http://www.w3.org/2000/svg",
+ xhtml: xhtml,
+ xlink: "http://www.w3.org/1999/xlink",
+ xml: "http://www.w3.org/XML/1998/namespace",
+ xmlns: "http://www.w3.org/2000/xmlns/"
+ };
+
+ function namespace(name) {
+ var prefix = name += "", i = prefix.indexOf(":");
+ if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
+ return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name;
+ }
+
+ function creatorInherit(name) {
+ return function() {
+ var document = this.ownerDocument,
+ uri = this.namespaceURI;
+ return uri === xhtml && document.documentElement.namespaceURI === xhtml
+ ? document.createElement(name)
+ : document.createElementNS(uri, name);
+ };
+ }
+
+ function creatorFixed(fullname) {
+ return function() {
+ return this.ownerDocument.createElementNS(fullname.space, fullname.local);
+ };
+ }
+
+ function creator(name) {
+ var fullname = namespace(name);
+ return (fullname.local
+ ? creatorFixed
+ : creatorInherit)(fullname);
+ }
+
+ function none() {}
+
+ function selector(selector) {
+ return selector == null ? none : function() {
+ return this.querySelector(selector);
+ };
+ }
+
+ function selection_select(select) {
+ if (typeof select !== "function") select = selector(select);
+
+ for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
+ for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
+ if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
+ if ("__data__" in node) subnode.__data__ = node.__data__;
+ subgroup[i] = subnode;
+ }
+ }
+ }
+
+ return new Selection(subgroups, this._parents);
+ }
+
+ function empty() {
+ return [];
+ }
+
+ function selectorAll(selector) {
+ return selector == null ? empty : function() {
+ return this.querySelectorAll(selector);
+ };
+ }
+
+ function selection_selectAll(select) {
+ if (typeof select !== "function") select = selectorAll(select);
+
+ for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
+ for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
+ if (node = group[i]) {
+ subgroups.push(select.call(node, node.__data__, i, group));
+ parents.push(node);
+ }
+ }
+ }
+
+ return new Selection(subgroups, parents);
+ }
+
+ function matcher(selector) {
+ return function() {
+ return this.matches(selector);
+ };
+ }
+
+ function selection_filter(match) {
+ if (typeof match !== "function") match = matcher(match);
+
+ for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
+ for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
+ if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
+ subgroup.push(node);
+ }
+ }
+ }
+
+ return new Selection(subgroups, this._parents);
+ }
+
+ function sparse(update) {
+ return new Array(update.length);
+ }
+
+ function selection_enter() {
+ return new Selection(this._enter || this._groups.map(sparse), this._parents);
+ }
+
+ function EnterNode(parent, datum) {
+ this.ownerDocument = parent.ownerDocument;
+ this.namespaceURI = parent.namespaceURI;
+ this._next = null;
+ this._parent = parent;
+ this.__data__ = datum;
+ }
+
+ EnterNode.prototype = {
+ constructor: EnterNode,
+ appendChild: function(child) { return this._parent.insertBefore(child, this._next); },
+ insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },
+ querySelector: function(selector) { return this._parent.querySelector(selector); },
+ querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }
+ };
+
+ function constant(x) {
+ return function() {
+ return x;
+ };
+ }
+
+ var keyPrefix = "$"; // Protect against keys like “__proto__”.
+
+ function bindIndex(parent, group, enter, update, exit, data) {
+ var i = 0,
+ node,
+ groupLength = group.length,
+ dataLength = data.length;
+
+ // Put any non-null nodes that fit into update.
+ // Put any null nodes into enter.
+ // Put any remaining data into enter.
+ for (; i < dataLength; ++i) {
+ if (node = group[i]) {
+ node.__data__ = data[i];
+ update[i] = node;
+ } else {
+ enter[i] = new EnterNode(parent, data[i]);
+ }
+ }
+
+ // Put any non-null nodes that don’t fit into exit.
+ for (; i < groupLength; ++i) {
+ if (node = group[i]) {
+ exit[i] = node;
+ }
+ }
+ }
+
+ function bindKey(parent, group, enter, update, exit, data, key) {
+ var i,
+ node,
+ nodeByKeyValue = {},
+ groupLength = group.length,
+ dataLength = data.length,
+ keyValues = new Array(groupLength),
+ keyValue;
+
+ // Compute the key for each node.
+ // If multiple nodes have the same key, the duplicates are added to exit.
+ for (i = 0; i < groupLength; ++i) {
+ if (node = group[i]) {
+ keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group);
+ if (keyValue in nodeByKeyValue) {
+ exit[i] = node;
+ } else {
+ nodeByKeyValue[keyValue] = node;
+ }
+ }
+ }
+
+ // Compute the key for each datum.
+ // If there a node associated with this key, join and add it to update.
+ // If there is not (or the key is a duplicate), add it to enter.
+ for (i = 0; i < dataLength; ++i) {
+ keyValue = keyPrefix + key.call(parent, data[i], i, data);
+ if (node = nodeByKeyValue[keyValue]) {
+ update[i] = node;
+ node.__data__ = data[i];
+ nodeByKeyValue[keyValue] = null;
+ } else {
+ enter[i] = new EnterNode(parent, data[i]);
+ }
+ }
+
+ // Add any remaining nodes that were not bound to data to exit.
+ for (i = 0; i < groupLength; ++i) {
+ if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) {
+ exit[i] = node;
+ }
+ }
+ }
+
+ function selection_data(value, key) {
+ if (!value) {
+ data = new Array(this.size()), j = -1;
+ this.each(function(d) { data[++j] = d; });
+ return data;
+ }
+
+ var bind = key ? bindKey : bindIndex,
+ parents = this._parents,
+ groups = this._groups;
+
+ if (typeof value !== "function") value = constant(value);
+
+ for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
+ var parent = parents[j],
+ group = groups[j],
+ groupLength = group.length,
+ data = value.call(parent, parent && parent.__data__, j, parents),
+ dataLength = data.length,
+ enterGroup = enter[j] = new Array(dataLength),
+ updateGroup = update[j] = new Array(dataLength),
+ exitGroup = exit[j] = new Array(groupLength);
+
+ bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
+
+ // Now connect the enter nodes to their following update node, such that
+ // appendChild can insert the materialized enter node before this node,
+ // rather than at the end of the parent node.
+ for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
+ if (previous = enterGroup[i0]) {
+ if (i0 >= i1) i1 = i0 + 1;
+ while (!(next = updateGroup[i1]) && ++i1 < dataLength);
+ previous._next = next || null;
+ }
+ }
+ }
+
+ update = new Selection(update, parents);
+ update._enter = enter;
+ update._exit = exit;
+ return update;
+ }
+
+ function selection_exit() {
+ return new Selection(this._exit || this._groups.map(sparse), this._parents);
+ }
+
+ function selection_join(onenter, onupdate, onexit) {
+ var enter = this.enter(), update = this, exit = this.exit();
+ enter = typeof onenter === "function" ? onenter(enter) : enter.append(onenter + "");
+ if (onupdate != null) update = onupdate(update);
+ if (onexit == null) exit.remove(); else onexit(exit);
+ return enter && update ? enter.merge(update).order() : update;
+ }
+
+ function selection_merge(selection) {
+
+ for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
+ for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
+ if (node = group0[i] || group1[i]) {
+ merge[i] = node;
+ }
+ }
+ }
+
+ for (; j < m0; ++j) {
+ merges[j] = groups0[j];
+ }
+
+ return new Selection(merges, this._parents);
+ }
+
+ function selection_order() {
+
+ for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {
+ for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
+ if (node = group[i]) {
+ if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
+ next = node;
+ }
+ }
+ }
+
+ return this;
+ }
+
+ function selection_sort(compare) {
+ if (!compare) compare = ascending;
+
+ function compareNode(a, b) {
+ return a && b ? compare(a.__data__, b.__data__) : !a - !b;
+ }
+
+ for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
+ for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
+ if (node = group[i]) {
+ sortgroup[i] = node;
+ }
+ }
+ sortgroup.sort(compareNode);
+ }
+
+ return new Selection(sortgroups, this._parents).order();
+ }
+
+ function ascending(a, b) {
+ return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+ }
+
+ function selection_call() {
+ var callback = arguments[0];
+ arguments[0] = this;
+ callback.apply(null, arguments);
+ return this;
+ }
+
+ function selection_nodes() {
+ var nodes = new Array(this.size()), i = -1;
+ this.each(function() { nodes[++i] = this; });
+ return nodes;
+ }
+
+ function selection_node() {
+
+ for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
+ for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
+ var node = group[i];
+ if (node) return node;
+ }
+ }
+
+ return null;
+ }
+
+ function selection_size() {
+ var size = 0;
+ this.each(function() { ++size; });
+ return size;
+ }
+
+ function selection_empty() {
+ return !this.node();
+ }
+
+ function selection_each(callback) {
+
+ for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
+ for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
+ if (node = group[i]) callback.call(node, node.__data__, i, group);
+ }
+ }
+
+ return this;
+ }
+
+ function attrRemove(name) {
+ return function() {
+ this.removeAttribute(name);
+ };
+ }
+
+ function attrRemoveNS(fullname) {
+ return function() {
+ this.removeAttributeNS(fullname.space, fullname.local);
+ };
+ }
+
+ function attrConstant(name, value) {
+ return function() {
+ this.setAttribute(name, value);
+ };
+ }
+
+ function attrConstantNS(fullname, value) {
+ return function() {
+ this.setAttributeNS(fullname.space, fullname.local, value);
+ };
+ }
+
+ function attrFunction(name, value) {
+ return function() {
+ var v = value.apply(this, arguments);
+ if (v == null) this.removeAttribute(name);
+ else this.setAttribute(name, v);
+ };
+ }
+
+ function attrFunctionNS(fullname, value) {
+ return function() {
+ var v = value.apply(this, arguments);
+ if (v == null) this.removeAttributeNS(fullname.space, fullname.local);
+ else this.setAttributeNS(fullname.space, fullname.local, v);
+ };
+ }
+
+ function selection_attr(name, value) {
+ var fullname = namespace(name);
+
+ if (arguments.length < 2) {
+ var node = this.node();
+ return fullname.local
+ ? node.getAttributeNS(fullname.space, fullname.local)
+ : node.getAttribute(fullname);
+ }
+
+ return this.each((value == null
+ ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function"
+ ? (fullname.local ? attrFunctionNS : attrFunction)
+ : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));
+ }
+
+ function defaultView(node) {
+ return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node
+ || (node.document && node) // node is a Window
+ || node.defaultView; // node is a Document
+ }
+
+ function styleRemove(name) {
+ return function() {
+ this.style.removeProperty(name);
+ };
+ }
+
+ function styleConstant(name, value, priority) {
+ return function() {
+ this.style.setProperty(name, value, priority);
+ };
+ }
+
+ function styleFunction(name, value, priority) {
+ return function() {
+ var v = value.apply(this, arguments);
+ if (v == null) this.style.removeProperty(name);
+ else this.style.setProperty(name, v, priority);
+ };
+ }
+
+ function selection_style(name, value, priority) {
+ return arguments.length > 1
+ ? this.each((value == null
+ ? styleRemove : typeof value === "function"
+ ? styleFunction
+ : styleConstant)(name, value, priority == null ? "" : priority))
+ : styleValue(this.node(), name);
+ }
+
+ function styleValue(node, name) {
+ return node.style.getPropertyValue(name)
+ || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);
+ }
+
+ function propertyRemove(name) {
+ return function() {
+ delete this[name];
+ };
+ }
+
+ function propertyConstant(name, value) {
+ return function() {
+ this[name] = value;
+ };
+ }
+
+ function propertyFunction(name, value) {
+ return function() {
+ var v = value.apply(this, arguments);
+ if (v == null) delete this[name];
+ else this[name] = v;
+ };
+ }
+
+ function selection_property(name, value) {
+ return arguments.length > 1
+ ? this.each((value == null
+ ? propertyRemove : typeof value === "function"
+ ? propertyFunction
+ : propertyConstant)(name, value))
+ : this.node()[name];
+ }
+
+ function classArray(string) {
+ return string.trim().split(/^|\s+/);
+ }
+
+ function classList(node) {
+ return node.classList || new ClassList(node);
+ }
+
+ function ClassList(node) {
+ this._node = node;
+ this._names = classArray(node.getAttribute("class") || "");
+ }
+
+ ClassList.prototype = {
+ add: function(name) {
+ var i = this._names.indexOf(name);
+ if (i < 0) {
+ this._names.push(name);
+ this._node.setAttribute("class", this._names.join(" "));
+ }
+ },
+ remove: function(name) {
+ var i = this._names.indexOf(name);
+ if (i >= 0) {
+ this._names.splice(i, 1);
+ this._node.setAttribute("class", this._names.join(" "));
+ }
+ },
+ contains: function(name) {
+ return this._names.indexOf(name) >= 0;
+ }
+ };
+
+ function classedAdd(node, names) {
+ var list = classList(node), i = -1, n = names.length;
+ while (++i < n) list.add(names[i]);
+ }
+
+ function classedRemove(node, names) {
+ var list = classList(node), i = -1, n = names.length;
+ while (++i < n) list.remove(names[i]);
+ }
+
+ function classedTrue(names) {
+ return function() {
+ classedAdd(this, names);
+ };
+ }
+
+ function classedFalse(names) {
+ return function() {
+ classedRemove(this, names);
+ };
+ }
+
+ function classedFunction(names, value) {
+ return function() {
+ (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
+ };
+ }
+
+ function selection_classed(name, value) {
+ var names = classArray(name + "");
+
+ if (arguments.length < 2) {
+ var list = classList(this.node()), i = -1, n = names.length;
+ while (++i < n) if (!list.contains(names[i])) return false;
+ return true;
+ }
+
+ return this.each((typeof value === "function"
+ ? classedFunction : value
+ ? classedTrue
+ : classedFalse)(names, value));
+ }
+
+ function textRemove() {
+ this.textContent = "";
+ }
+
+ function textConstant(value) {
+ return function() {
+ this.textContent = value;
+ };
+ }
+
+ function textFunction(value) {
+ return function() {
+ var v = value.apply(this, arguments);
+ this.textContent = v == null ? "" : v;
+ };
+ }
+
+ function selection_text(value) {
+ return arguments.length
+ ? this.each(value == null
+ ? textRemove : (typeof value === "function"
+ ? textFunction
+ : textConstant)(value))
+ : this.node().textContent;
+ }
+
+ function htmlRemove() {
+ this.innerHTML = "";
+ }
+
+ function htmlConstant(value) {
+ return function() {
+ this.innerHTML = value;
+ };
+ }
+
+ function htmlFunction(value) {
+ return function() {
+ var v = value.apply(this, arguments);
+ this.innerHTML = v == null ? "" : v;
+ };
+ }
+
+ function selection_html(value) {
+ return arguments.length
+ ? this.each(value == null
+ ? htmlRemove : (typeof value === "function"
+ ? htmlFunction
+ : htmlConstant)(value))
+ : this.node().innerHTML;
+ }
+
+ function raise() {
+ if (this.nextSibling) this.parentNode.appendChild(this);
+ }
+
+ function selection_raise() {
+ return this.each(raise);
+ }
+
+ function lower() {
+ if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
+ }
+
+ function selection_lower() {
+ return this.each(lower);
+ }
+
+ function selection_append(name) {
+ var create = typeof name === "function" ? name : creator(name);
+ return this.select(function() {
+ return this.appendChild(create.apply(this, arguments));
+ });
+ }
+
+ function constantNull() {
+ return null;
+ }
+
+ function selection_insert(name, before) {
+ var create = typeof name === "function" ? name : creator(name),
+ select = before == null ? constantNull : typeof before === "function" ? before : selector(before);
+ return this.select(function() {
+ return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
+ });
+ }
+
+ function remove() {
+ var parent = this.parentNode;
+ if (parent) parent.removeChild(this);
+ }
+
+ function selection_remove() {
+ return this.each(remove);
+ }
+
+ function selection_cloneShallow() {
+ return this.parentNode.insertBefore(this.cloneNode(false), this.nextSibling);
+ }
+
+ function selection_cloneDeep() {
+ return this.parentNode.insertBefore(this.cloneNode(true), this.nextSibling);
+ }
+
+ function selection_clone(deep) {
+ return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
+ }
+
+ function selection_datum(value) {
+ return arguments.length
+ ? this.property("__data__", value)
+ : this.node().__data__;
+ }
+
+ var filterEvents = {};
+
+ if (typeof document !== "undefined") {
+ var element = document.documentElement;
+ if (!("onmouseenter" in element)) {
+ filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"};
+ }
+ }
+
+ function filterContextListener(listener, index, group) {
+ listener = contextListener(listener, index, group);
+ return function(event) {
+ var related = event.relatedTarget;
+ if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) {
+ listener.call(this, event);
+ }
+ };
+ }
+
+ function contextListener(listener, index, group) {
+ return function(event1) {
+ try {
+ listener.call(this, this.__data__, index, group);
+ } finally {
+ }
+ };
+ }
+
+ function parseTypenames(typenames) {
+ return typenames.trim().split(/^|\s+/).map(function(t) {
+ var name = "", i = t.indexOf(".");
+ if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
+ return {type: t, name: name};
+ });
+ }
+
+ function onRemove(typename) {
+ return function() {
+ var on = this.__on;
+ if (!on) return;
+ for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
+ if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
+ this.removeEventListener(o.type, o.listener, o.capture);
+ } else {
+ on[++i] = o;
+ }
+ }
+ if (++i) on.length = i;
+ else delete this.__on;
+ };
+ }
+
+ function onAdd(typename, value, capture) {
+ var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener;
+ return function(d, i, group) {
+ var on = this.__on, o, listener = wrap(value, i, group);
+ if (on) for (var j = 0, m = on.length; j < m; ++j) {
+ if ((o = on[j]).type === typename.type && o.name === typename.name) {
+ this.removeEventListener(o.type, o.listener, o.capture);
+ this.addEventListener(o.type, o.listener = listener, o.capture = capture);
+ o.value = value;
+ return;
+ }
+ }
+ this.addEventListener(typename.type, listener, capture);
+ o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture};
+ if (!on) this.__on = [o];
+ else on.push(o);
+ };
+ }
+
+ function selection_on(typename, value, capture) {
+ var typenames = parseTypenames(typename + ""), i, n = typenames.length, t;
+
+ if (arguments.length < 2) {
+ var on = this.node().__on;
+ if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
+ for (i = 0, o = on[j]; i < n; ++i) {
+ if ((t = typenames[i]).type === o.type && t.name === o.name) {
+ return o.value;
+ }
+ }
+ }
+ return;
+ }
+
+ on = value ? onAdd : onRemove;
+ if (capture == null) capture = false;
+ for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture));
+ return this;
+ }
+
+ function dispatchEvent(node, type, params) {
+ var window = defaultView(node),
+ event = window.CustomEvent;
+
+ if (typeof event === "function") {
+ event = new event(type, params);
+ } else {
+ event = window.document.createEvent("Event");
+ if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;
+ else event.initEvent(type, false, false);
+ }
+
+ node.dispatchEvent(event);
+ }
+
+ function dispatchConstant(type, params) {
+ return function() {
+ return dispatchEvent(this, type, params);
+ };
+ }
+
+ function dispatchFunction(type, params) {
+ return function() {
+ return dispatchEvent(this, type, params.apply(this, arguments));
+ };
+ }
+
+ function selection_dispatch(type, params) {
+ return this.each((typeof params === "function"
+ ? dispatchFunction
+ : dispatchConstant)(type, params));
+ }
+
+ var root = [null];
+
+ function Selection(groups, parents) {
+ this._groups = groups;
+ this._parents = parents;
+ }
+
+ function selection() {
+ return new Selection([[document.documentElement]], root);
+ }
+
+ Selection.prototype = selection.prototype = {
+ constructor: Selection,
+ select: selection_select,
+ selectAll: selection_selectAll,
+ filter: selection_filter,
+ data: selection_data,
+ enter: selection_enter,
+ exit: selection_exit,
+ join: selection_join,
+ merge: selection_merge,
+ order: selection_order,
+ sort: selection_sort,
+ call: selection_call,
+ nodes: selection_nodes,
+ node: selection_node,
+ size: selection_size,
+ empty: selection_empty,
+ each: selection_each,
+ attr: selection_attr,
+ style: selection_style,
+ property: selection_property,
+ classed: selection_classed,
+ text: selection_text,
+ html: selection_html,
+ raise: selection_raise,
+ lower: selection_lower,
+ append: selection_append,
+ insert: selection_insert,
+ remove: selection_remove,
+ clone: selection_clone,
+ datum: selection_datum,
+ on: selection_on,
+ dispatch: selection_dispatch
+ };
+
+ function select(selector) {
+ return typeof selector === "string"
+ ? new Selection([[document.querySelector(selector)]], [document.documentElement])
+ : new Selection([[selector]], root);
+ }
+
+ /*
+ Uses the Mediawiki API to display a list of recent images and a link to
+ the page where the image has been used/placed.
+
+ Makes use of the following API calls:
+
+ * https://www.mediawiki.org/wiki/API:Allimages
+ * https://www.mediawiki.org/wiki/API:Imageinfo
+ * https://www.mediawiki.org/wiki/API:Imageusage
+ */
+ var PAGE_COUNT = 25; /* how many edits to show per load*/
+ var main = select("#content"),
+ baseurl = "/mw/api.php?action=query&list=recentchanges&rclimit=25&rcnamespace=0&rctoponly=1&format=json&formatversion=2&aisort=timestamp&aidir=older&aiprop=timestamp|user|url|mime|size",
+ url = baseurl;
+
+ async function get_json (url) {
+ var resp = await fetch(url);
+ return await resp.json();
+ }
+
+ function url_for_title (title) {
+ return "/w/"+encodeURI(title.replace(/ /g, "_"));
+ }
+
+ async function load () {
+ let count = 0;
+ while (count < PAGE_COUNT) {
+ // console.log("starting loop", "count", count, "url", url);
+ let data = await get_json(url),
+ recentchanges = data.query.recentchanges;
+ console.log("recentchanges", recentchanges);
+ let items = main.selectAll("div.edit")
+ .data(recentchanges, d=>d.title)
+ .enter()
+ .append("div")
+ .attr("class", "edit")
+ .append("a")
+ .attr("href", d=>url_for_title(d.title))
+ .attr("target", "wikiframe")
+ .text(d=>d.title);
+
+ if (data.continue) {
+ url = baseurl+"&rccontinue="+data.continue.rccontinue;
+ } else {
+ return;
+ }
+ count += recentchanges.length;
+ }
+ }
+ document.addEventListener("DOMContentLoaded", load);
+ document.querySelector("a#more").addEventListener("click", function (e) {
+ e.preventDefault();
+ load();
+ });
+
+}());
diff --git a/special/recentchanges/index.html b/special/recentchanges/index.html
new file mode 100644
index 0000000..4be4d62
--- /dev/null
+++ b/special/recentchanges/index.html
@@ -0,0 +1,53 @@
+
+
+
+
erg: modifications récentes
+
+
+
+
+
+
Modifications récentes
+
+
+
+
+
diff --git a/special/recentchanges/package.json b/special/recentchanges/package.json
new file mode 100644
index 0000000..012e95d
--- /dev/null
+++ b/special/recentchanges/package.json
@@ -0,0 +1,16 @@
+{
+ "name": "recentfiles",
+ "version": "1.0.0",
+ "description": "",
+ "main": "rollup.config.js",
+ "scripts": {
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "keywords": [],
+ "author": "",
+ "license": "ISC",
+ "dependencies": {
+ "d3-selection": "^1.4.0",
+ "rollup": "^1.17.0"
+ }
+}
diff --git a/special/recentchanges/rollup.config.js b/special/recentchanges/rollup.config.js
new file mode 100644
index 0000000..81da768
--- /dev/null
+++ b/special/recentchanges/rollup.config.js
@@ -0,0 +1,17 @@
+// rollup.config.js
+// https://github.com/rollup/rollup-plugin-commonjs
+import commonjs from 'rollup-plugin-commonjs';
+import resolve from 'rollup-plugin-node-resolve';
+
+export default [{
+ input: 'src/recentchanges.js',
+ output: {
+ file: 'dist/recentchanges.js',
+ format: 'iife',
+ name: 'app'
+ },
+ plugins: [
+ resolve(),
+ commonjs()
+ ]
+}];
\ No newline at end of file
diff --git a/special/recentchanges/src/recentchanges.js b/special/recentchanges/src/recentchanges.js
new file mode 100644
index 0000000..37e59f3
--- /dev/null
+++ b/special/recentchanges/src/recentchanges.js
@@ -0,0 +1,55 @@
+import { selectAll, select } from 'd3-selection';
+/*
+Uses the Mediawiki API to display a list of recent images and a link to
+the page where the image has been used/placed.
+
+Makes use of the following API calls:
+
+* https://www.mediawiki.org/wiki/API:Allimages
+* https://www.mediawiki.org/wiki/API:Imageinfo
+* https://www.mediawiki.org/wiki/API:Imageusage
+*/
+var PAGE_COUNT = 25; /* how many edits to show per load*/
+var main = select("#content"),
+ baseurl = "/mw/api.php?action=query&list=recentchanges&rclimit=25&rcnamespace=0&rctoponly=1&format=json&formatversion=2&aisort=timestamp&aidir=older&aiprop=timestamp|user|url|mime|size",
+ url = baseurl;
+
+async function get_json (url) {
+ var resp = await fetch(url);
+ return await resp.json();
+}
+
+function url_for_title (title) {
+ return "/w/"+encodeURI(title.replace(/ /g, "_"));
+}
+
+async function load () {
+ let count = 0;
+ while (count < PAGE_COUNT) {
+ // console.log("starting loop", "count", count, "url", url);
+ let data = await get_json(url),
+ recentchanges = data.query.recentchanges;
+ console.log("recentchanges", recentchanges);
+ let items = main.selectAll("div.edit")
+ .data(recentchanges, d=>d.title)
+ .enter()
+ .append("div")
+ .attr("class", "edit")
+ .append("a")
+ .attr("href", d=>url_for_title(d.title))
+ .attr("target", "wikiframe")
+ .text(d=>d.title);
+
+ if (data.continue) {
+ url = baseurl+"&rccontinue="+data.continue.rccontinue;
+ } else {
+ return;
+ }
+ count += recentchanges.length;
+ }
+}
+document.addEventListener("DOMContentLoaded", load);
+document.querySelector("a#more").addEventListener("click", function (e) {
+ e.preventDefault();
+ load();
+});
\ No newline at end of file
diff --git a/special/recentfiles/dist/recentfiles.js b/special/recentfiles/dist/recentfiles.js
index 7100e62..e07971f 100644
--- a/special/recentfiles/dist/recentfiles.js
+++ b/special/recentfiles/dist/recentfiles.js
@@ -858,7 +858,6 @@
}
/*
-
Uses the Mediawiki API to display a list of recent images and a link to
the page where the image has been used/placed.
@@ -867,9 +866,11 @@
* https://www.mediawiki.org/wiki/API:Allimages
* https://www.mediawiki.org/wiki/API:Imageinfo
* https://www.mediawiki.org/wiki/API:Imageusage
-
*/
var NUM_FILES = 10; /* how many files to show */
+ var main = select("#content"),
+ baseurl = "/mw/api.php?action=query&list=allimages&ailimit=1&format=json&formatversion=2&aisort=timestamp&aidir=older&aiprop=timestamp|user|url|mime|size",
+ url = baseurl;
async function get_json (url) {
var resp = await fetch(url);
@@ -881,43 +882,29 @@
}
async function load () {
- var main = select("#content"),
- baseurl = "/mw/api.php?action=query&list=allimages&ailimit=1&format=json&formatversion=2&aisort=timestamp&aidir=older&aiprop=timestamp|user|url|mime|size",
- url = baseurl,
- count = 0;
+ let count = 0;
while (count < NUM_FILES) {
- // console.log("starting loop", debugloopcount, "count", count, "url", url);
- let resp = await fetch(url),
- data = await resp.json(),
+ // console.log("starting loop", "count", count, "url", url);
+ let data = await get_json(url),
allimages = data.query.allimages,
useimages = [];
+
// console.log("got data", data.query.allimages.length);
- // For each image:
- // Use API:Imageinfo request/get the URL to a thumbnail image
- //
for (var i=0, l=allimages.length; i
d.imageinfo.thumburl && (d.imageusage.length > 0));
let items = main.selectAll("div.file")
.data(useimages, d=>d.title)
.enter()
@@ -929,14 +916,16 @@
.append("img")
.attr('src', d=>d.imageinfo.thumburl);
- count += useimages.length;
if (data.continue) {
url = baseurl+"&aicontinue="+data.continue.aicontinue;
}
- // if (debugloopcount >= 5) break;
+ count += useimages.length;
}
-
}
document.addEventListener("DOMContentLoaded", load);
+ document.querySelector("a#more").addEventListener("click", function (e) {
+ e.preventDefault();
+ load();
+ });
}());
diff --git a/special/recentfiles/recentfiles.html b/special/recentfiles/index.html
similarity index 71%
rename from special/recentfiles/recentfiles.html
rename to special/recentfiles/index.html
index a78ec21..e883a63 100644
--- a/special/recentfiles/recentfiles.html
+++ b/special/recentfiles/index.html
@@ -18,10 +18,21 @@
div.file img {
max-width: 100%;
}
+ div#footer {
+ clear: both;
+ text-align: center;
+ }
+ a#more {
+ color: white;
+ text-decoration: none;
+ background: black;
+ padding: 5px;
+ }
+