'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;