mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/Cite
synced 2024-12-20 18:42:41 +00:00
484 lines
16 KiB
JavaScript
484 lines
16 KiB
JavaScript
'use strict';
|
|
|
|
const ParsoidExtApi = module.parent.parent.require('./extapi.js').versionCheck('^0.11.0');
|
|
const { ContentUtils, DOMDataUtils, DOMUtils, TokenUtils, WTUtils, Promise } = ParsoidExtApi;
|
|
|
|
/**
|
|
* @class
|
|
*/
|
|
class References {
|
|
static hasRef(node) {
|
|
var c = node.firstChild;
|
|
while (c) {
|
|
if (DOMUtils.isElt(c)) {
|
|
if (WTUtils.isSealedFragmentOfType(c, 'ref')) {
|
|
return true;
|
|
}
|
|
if (References.hasRef(c)) {
|
|
return true;
|
|
}
|
|
}
|
|
c = c.nextSibling;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static toDOM(state, content, args) {
|
|
return ParsoidExtApi.parseTokenContentsToDOM(state, args, '', content, {
|
|
wrapperTag: 'div',
|
|
pipelineOpts: {
|
|
extTag: 'references',
|
|
inTemplate: state.parseContext.inTemplate,
|
|
},
|
|
}).then(function(doc) {
|
|
var refsOpts = Object.assign({
|
|
group: null,
|
|
responsive: null,
|
|
}, TokenUtils.kvToHash(args, true));
|
|
|
|
var frag = References.createReferences(state.env, doc, doc.body, refsOpts, function(dp) {
|
|
dp.src = state.extToken.hasAttribute('source') ? state.extToken.getAttribute('source') : null;
|
|
// Redundant - also present on doc.body.firstChild, but feels cumbersome to use
|
|
dp.selfClose = state.extToken.dataAttribs.selfClose;
|
|
});
|
|
doc.body.appendChild(frag);
|
|
|
|
return doc;
|
|
});
|
|
}
|
|
|
|
static createReferences(env, doc, body, refsOpts, modifyDp, autoGenerated) {
|
|
var ol = doc.createElement('ol');
|
|
ol.classList.add('mw-references');
|
|
ol.classList.add('references');
|
|
|
|
if (body) {
|
|
DOMUtils.migrateChildren(body, ol);
|
|
}
|
|
|
|
// Support the `responsive` parameter
|
|
var rrOpts = env.conf.wiki.responsiveReferences;
|
|
var responsiveWrap = rrOpts.enabled;
|
|
if (refsOpts.responsive !== null) {
|
|
responsiveWrap = refsOpts.responsive !== '0';
|
|
}
|
|
|
|
var frag;
|
|
if (responsiveWrap) {
|
|
var div = doc.createElement('div');
|
|
div.classList.add('mw-references-wrap');
|
|
div.appendChild(ol);
|
|
frag = div;
|
|
} else {
|
|
frag = ol;
|
|
}
|
|
|
|
if (autoGenerated) {
|
|
DOMDataUtils.addAttributes(frag, {
|
|
typeof: 'mw:Extension/references',
|
|
about: env.newAboutId(),
|
|
});
|
|
}
|
|
|
|
var dp = DOMDataUtils.getDataParsoid(frag);
|
|
if (refsOpts.group) { // No group for the empty string either
|
|
dp.group = refsOpts.group;
|
|
ol.setAttribute('data-mw-group', refsOpts.group);
|
|
}
|
|
if (typeof modifyDp === 'function') {
|
|
modifyDp(dp);
|
|
}
|
|
|
|
return frag;
|
|
}
|
|
|
|
static extractRefFromNode(node, refsData, referencesAboutId, referencesGroup, nestedRefsHTML) {
|
|
var env = refsData.env;
|
|
var doc = node.ownerDocument;
|
|
var nestedInReferences = referencesAboutId !== undefined;
|
|
|
|
// This is data-parsoid from the dom fragment node that's gone through
|
|
// dsr computation and template wrapping.
|
|
var nodeDp = DOMDataUtils.getDataParsoid(node);
|
|
var typeOf = node.getAttribute('typeof') || '';
|
|
var isTplWrapper = DOMUtils.matchTypeOf(node, /^mw:Transclusion$/);
|
|
var nodeType = typeOf.replace(/mw:DOMFragment\/sealed\/ref/, '');
|
|
var content = nodeDp.html;
|
|
var tplDmw = isTplWrapper ? DOMDataUtils.getDataMw(node) : null;
|
|
|
|
// This is the <sup> that's the meat of the sealed fragment
|
|
var c = env.fragmentMap.get(content)[0];
|
|
// All the actions that require loaded data-attributes on `c` are done
|
|
// here so that we can quickly store those away for later.
|
|
DOMDataUtils.visitAndLoadDataAttribs(c);
|
|
var cDp = DOMDataUtils.getDataParsoid(c);
|
|
var refDmw = DOMDataUtils.getDataMw(c);
|
|
if (!cDp.empty && References.hasRef(c)) { // nested ref-in-ref
|
|
References._processRefs(env, refsData, c);
|
|
}
|
|
DOMDataUtils.visitAndStoreDataAttribs(c);
|
|
|
|
// Use the about attribute on the wrapper with priority, since it's
|
|
// only added when the wrapper is a template sibling.
|
|
const about = node.hasAttribute('about') ? node.getAttribute('about') :
|
|
c.hasAttribute('about') ? c.getAttribute('about') : '';
|
|
|
|
// FIXME(SSS): Need to clarify semantics here.
|
|
// If both the containing <references> elt as well as the nested <ref>
|
|
// elt has a group attribute, what takes precedence?
|
|
var group = refDmw.attrs.group || referencesGroup || '';
|
|
var refName = refDmw.attrs.name || '';
|
|
var ref = refsData.add(env, group, refName, about, nestedInReferences);
|
|
|
|
// Add ref-index linkback
|
|
var linkBack = doc.createElement('sup');
|
|
|
|
// FIXME: Lot of useless work for an edge case
|
|
if (cDp.empty) {
|
|
// Discard wrapper if there was no input wikitext
|
|
content = null;
|
|
if (cDp.selfClose) {
|
|
refDmw.body = undefined;
|
|
} else {
|
|
refDmw.body = { 'html': '' };
|
|
}
|
|
} else {
|
|
// If there are multiple <ref>s with the same name, but different content,
|
|
// the content of the first <ref> shows up in the <references> section.
|
|
// in order to ensure lossless RT-ing for later <refs>, we have to record
|
|
// HTML inline for all of them.
|
|
var html = '';
|
|
var contentDiffers = false;
|
|
if (ref.hasMultiples) {
|
|
// Use the non-pp version here since we've already stored attribs
|
|
// before putting them in the map.
|
|
html = ContentUtils.toXML(c, { innerXML: true });
|
|
contentDiffers = html !== ref.cachedHtml;
|
|
}
|
|
if (contentDiffers) {
|
|
refDmw.body = { 'html': html };
|
|
} else {
|
|
refDmw.body = { 'id': "mw-reference-text-" + ref.target };
|
|
}
|
|
}
|
|
|
|
DOMDataUtils.addAttributes(linkBack, {
|
|
'about': about,
|
|
'class': 'mw-ref',
|
|
'id': nestedInReferences ? undefined :
|
|
(ref.name ? ref.linkbacks[ref.linkbacks.length - 1] : ref.id),
|
|
'rel': 'dc:references',
|
|
'typeof': nodeType,
|
|
});
|
|
DOMDataUtils.addTypeOf(linkBack, "mw:Extension/ref");
|
|
var dataParsoid = {
|
|
src: nodeDp.src,
|
|
dsr: nodeDp.dsr,
|
|
pi: nodeDp.pi,
|
|
};
|
|
DOMDataUtils.setDataParsoid(linkBack, dataParsoid);
|
|
if (isTplWrapper) {
|
|
DOMDataUtils.setDataMw(linkBack, tplDmw);
|
|
} else {
|
|
DOMDataUtils.setDataMw(linkBack, refDmw);
|
|
}
|
|
|
|
// refLink is the link to the citation
|
|
var refLink = doc.createElement('a');
|
|
DOMDataUtils.addAttributes(refLink, {
|
|
'href': env.page.titleURI + '#' + ref.target,
|
|
'style': 'counter-reset: mw-Ref ' + ref.groupIndex + ';',
|
|
});
|
|
if (ref.group) {
|
|
refLink.setAttribute('data-mw-group', ref.group);
|
|
}
|
|
|
|
// refLink-span which will contain a default rendering of the cite link
|
|
// for browsers that don't support counters
|
|
var refLinkSpan = doc.createElement('span');
|
|
refLinkSpan.setAttribute('class', 'mw-reflink-text');
|
|
refLinkSpan.appendChild(doc.createTextNode("[" +
|
|
(ref.group ? ref.group + " " : "") + ref.groupIndex + "]"));
|
|
refLink.appendChild(refLinkSpan);
|
|
linkBack.appendChild(refLink);
|
|
|
|
if (!nestedInReferences) {
|
|
node.parentNode.replaceChild(linkBack, node);
|
|
} else {
|
|
// We don't need to delete the node now since it'll be removed in
|
|
// `insertReferencesIntoDOM` when all the children all cleaned out.
|
|
nestedRefsHTML.push(ContentUtils.ppToXML(linkBack), '\n');
|
|
}
|
|
|
|
// Keep the first content to compare multiple <ref>s with the same name.
|
|
if (!ref.content) {
|
|
ref.content = content;
|
|
ref.dir = (refDmw.attrs.dir || '').toLowerCase();
|
|
}
|
|
}
|
|
|
|
static insertReferencesIntoDOM(refsNode, refsData, nestedRefsHTML, autoGenerated) {
|
|
var env = refsData.env;
|
|
var isTplWrapper = DOMUtils.matchTypeOf(refsNode, /^mw:Transclusion$/);
|
|
var dp = DOMDataUtils.getDataParsoid(refsNode);
|
|
var group = dp.group || '';
|
|
if (!isTplWrapper) {
|
|
var dataMw = DOMDataUtils.getDataMw(refsNode);
|
|
if (!Object.keys(dataMw).length) {
|
|
// FIXME: This can be moved to `insertMissingReferencesIntoDOM`
|
|
console.assert(autoGenerated);
|
|
dataMw = {
|
|
'name': 'references',
|
|
'attrs': {
|
|
'group': group || undefined, // Dont emit empty keys
|
|
},
|
|
};
|
|
DOMDataUtils.setDataMw(refsNode, dataMw);
|
|
}
|
|
|
|
// Mark this auto-generated so that we can skip this during
|
|
// html -> wt and so that clients can strip it if necessary.
|
|
if (autoGenerated) {
|
|
dataMw.autoGenerated = true;
|
|
} else if (nestedRefsHTML.length > 0) {
|
|
dataMw.body = { 'html': '\n' + nestedRefsHTML.join('') };
|
|
} else if (!dp.selfClose) {
|
|
dataMw.body = { 'html': '' };
|
|
} else {
|
|
dataMw.body = undefined;
|
|
}
|
|
dp.selfClose = undefined;
|
|
}
|
|
|
|
var refGroup = refsData.getRefGroup(group);
|
|
|
|
// Deal with responsive wrapper
|
|
if (refsNode.classList.contains('mw-references-wrap')) {
|
|
var rrOpts = env.conf.wiki.responsiveReferences;
|
|
if (refGroup && refGroup.refs.length > rrOpts.threshold) {
|
|
refsNode.classList.add('mw-references-columns');
|
|
}
|
|
refsNode = refsNode.firstChild;
|
|
}
|
|
|
|
// Remove all children from the references node
|
|
//
|
|
// Ex: When {{Reflist}} is reused from the cache, it comes with
|
|
// a bunch of references as well. We have to remove all those cached
|
|
// references before generating fresh references.
|
|
while (refsNode.firstChild) {
|
|
refsNode.removeChild(refsNode.firstChild);
|
|
}
|
|
|
|
if (refGroup) {
|
|
refGroup.refs.forEach(ref => refGroup.renderLine(env, refsNode, ref));
|
|
}
|
|
|
|
// Remove the group from refsData
|
|
refsData.removeRefGroup(group);
|
|
}
|
|
|
|
/**
|
|
* Process `<ref>`s left behind after the DOM is fully processed.
|
|
* We process them as if there was an implicit `<references />` tag at
|
|
* the end of the DOM.
|
|
*/
|
|
static insertMissingReferencesIntoDOM(refsData, node) {
|
|
var env = refsData.env;
|
|
var doc = node.ownerDocument;
|
|
|
|
refsData.refGroups.forEach((refsValue, refsGroup) => {
|
|
var frag = References.createReferences(env, doc, null, {
|
|
group: refsGroup,
|
|
responsive: null,
|
|
}, function(dp) {
|
|
// The new references come out of "nowhere", so to make selser work
|
|
// propertly, add a zero-sized DSR pointing to the end of the document.
|
|
dp.dsr = [env.page.src.length, env.page.src.length, 0, 0];
|
|
}, true);
|
|
|
|
// Add a \n before the <ol> so that when serialized to wikitext,
|
|
// each <references /> tag appears on its own line.
|
|
node.appendChild(doc.createTextNode("\n"));
|
|
node.appendChild(frag);
|
|
|
|
References.insertReferencesIntoDOM(frag, refsData, [""], true);
|
|
});
|
|
}
|
|
|
|
static lintHandler(refs, env, tplInfo, domLinter) {
|
|
// Nothing to do
|
|
//
|
|
// FIXME: Not entirely true for scenarios where the <ref> tags
|
|
// are defined in the references section that is itself templated.
|
|
//
|
|
// {{1x|<references>\n<ref name='x'><b>foo</ref>\n</references>}}
|
|
//
|
|
// In this example, the references tag has the right tplInfo and
|
|
// when the <ref> tag is processed in the body of the article where
|
|
// it is accessed, there is no relevant template or dsr info available.
|
|
//
|
|
// Ignoring for now.
|
|
return refs.nextSibling;
|
|
}
|
|
|
|
static processEmbeddedRefs(env, refsData, str) {
|
|
const dom = ContentUtils.ppToDOM(env, str);
|
|
References._processRefs(env, refsData, dom);
|
|
return ContentUtils.ppToXML(dom, { innerXML: true });
|
|
}
|
|
|
|
static _processRefs(env, refsData, node) {
|
|
var child = node.firstChild;
|
|
while (child !== null) {
|
|
var nextChild = child.nextSibling;
|
|
if (DOMUtils.isElt(child)) {
|
|
if (WTUtils.isSealedFragmentOfType(child, 'ref')) {
|
|
References.extractRefFromNode(child, refsData);
|
|
} else if (DOMUtils.matchTypeOf(child, /^mw:Extension\/references$/)) {
|
|
var referencesId = child.getAttribute("about") || '';
|
|
var referencesGroup = DOMDataUtils.getDataParsoid(child).group;
|
|
var nestedRefsHTML = [];
|
|
References._processRefsInReferences(refsData, child, referencesId, referencesGroup, nestedRefsHTML);
|
|
References.insertReferencesIntoDOM(child, refsData, nestedRefsHTML);
|
|
} else {
|
|
/* -----------------------------------------------------------------
|
|
* FIXME(subbu): This works but feels very special-cased in 2 ways:
|
|
*
|
|
* 1. special cased to specific node types below vs. any node that might
|
|
* have serialized HTML embedded in data-mw
|
|
* 2. special cased to global cite handling -- the general scenario
|
|
* is DOM post-processors that do different things on the
|
|
* top-level vs not.
|
|
* - Cite needs to process these fragments in the context of the
|
|
* top-level page, and has to be done in order of how the nodes
|
|
* are encountered.
|
|
* - DOM cleanup can be done on embedded fragments without
|
|
* any page-level context and in any order.
|
|
* - So, some variability here.
|
|
*
|
|
* We should be running dom.cleanup.js passes on embedded html
|
|
* in data-mw and other attributes. Since correctness doesn't
|
|
* depend on that cleanup, I am not adding more special-case
|
|
* code in dom.cleanup.js.
|
|
*
|
|
* Doing this more generically will require creating a DOMProcessor
|
|
* class and adding state to it.
|
|
*
|
|
* See T214994
|
|
* ----------------------------------------------------------------- */
|
|
// Expanded attributes
|
|
if (DOMUtils.matchTypeOf(child, /^mw:ExpandedAttrs$/)) {
|
|
const dmw = DOMDataUtils.getDataMw(child);
|
|
if (dmw.attribs && dmw.attribs.length > 0) {
|
|
const attribs = dmw.attribs[0];
|
|
attribs.forEach(function(a) {
|
|
if (a.html) {
|
|
a.html = References.processEmbeddedRefs(env, refsData, a.html);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// Language variant markup
|
|
if (DOMUtils.matchTypeOf(child, /^mw:LanguageVariant$/)) {
|
|
const dmwv = DOMDataUtils.getJSONAttribute(child, 'data-mw-variant', null);
|
|
if (dmwv) {
|
|
if (dmwv.disabled) {
|
|
dmwv.disabled.t = References.processEmbeddedRefs(env, refsData, dmwv.disabled.t);
|
|
}
|
|
if (dmwv.twoway) {
|
|
dmwv.twoway.forEach(function(l) {
|
|
l.t = References.processEmbeddedRefs(env, refsData, l.t);
|
|
});
|
|
}
|
|
if (dmwv.oneway) {
|
|
dmwv.oneway.forEach(function(l) {
|
|
l.f = References.processEmbeddedRefs(env, refsData, l.f);
|
|
l.t = References.processEmbeddedRefs(env, refsData, l.t);
|
|
});
|
|
}
|
|
if (dmwv.filter) {
|
|
dmwv.filter.t = References.processEmbeddedRefs(env, refsData, dmwv.filter.t);
|
|
}
|
|
DOMDataUtils.setJSONAttribute(child, 'data-mw-variant', dmwv);
|
|
}
|
|
}
|
|
|
|
// Inline media -- look inside the data-mw attribute
|
|
if (WTUtils.isInlineMedia(child)) {
|
|
const dmw = DOMDataUtils.getDataMw(child);
|
|
if (dmw.caption) {
|
|
dmw.caption = References.processEmbeddedRefs(env, refsData, dmw.caption);
|
|
}
|
|
}
|
|
|
|
if (child.hasChildNodes()) {
|
|
References._processRefs(env, refsData, child);
|
|
}
|
|
}
|
|
}
|
|
child = nextChild;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This handles wikitext like this:
|
|
* ```
|
|
* <references> <ref>foo</ref> </references>
|
|
* <references> <ref>bar</ref> </references>
|
|
* ```
|
|
* @private
|
|
*/
|
|
static _processRefsInReferences(refsData, node, referencesId, referencesGroup, nestedRefsHTML) {
|
|
var child = node.firstChild;
|
|
while (child !== null) {
|
|
var nextChild = child.nextSibling;
|
|
if (DOMUtils.isElt(child)) {
|
|
if (WTUtils.isSealedFragmentOfType(child, 'ref')) {
|
|
References.extractRefFromNode(child, refsData, referencesId, referencesGroup, nestedRefsHTML);
|
|
} else if (child.hasChildNodes()) {
|
|
References._processRefsInReferences(refsData, child, referencesId, referencesGroup, nestedRefsHTML);
|
|
}
|
|
}
|
|
child = nextChild;
|
|
}
|
|
}
|
|
}
|
|
|
|
References.serialHandler = {
|
|
handle: Promise.async(function *(node, state, wrapperUnmodified) {
|
|
var dataMw = DOMDataUtils.getDataMw(node);
|
|
if (dataMw.autoGenerated && state.rtTestMode) {
|
|
// Eliminate auto-inserted <references /> noise in rt-testing
|
|
return '';
|
|
} else {
|
|
var startTagSrc = yield state.serializer.serializeExtensionStartTag(node, state);
|
|
if (!dataMw.body) {
|
|
return startTagSrc; // We self-closed this already.
|
|
} else if (typeof dataMw.body.html === 'string') {
|
|
var src = yield state.serializer.serializeHTML({
|
|
env: state.env,
|
|
extName: dataMw.name,
|
|
}, dataMw.body.html);
|
|
return startTagSrc + src + '</' + dataMw.name + '>';
|
|
} else {
|
|
state.env.log('error',
|
|
'References body unavailable for: ' + node.outerHTML);
|
|
return ''; // Drop it!
|
|
}
|
|
}
|
|
}),
|
|
// FIXME: LEAKY -- Should we expose newline constraints to extensions?
|
|
before: function(node, otherNode, state) {
|
|
// Serialize new references tags on a new line.
|
|
if (WTUtils.isNewElt(node)) {
|
|
return { min: 1, max: 2 };
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
};
|
|
|
|
module.exports = References;
|