Você não pode selecionar mais de 25 tópicos
Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
509 linhas
17 KiB
509 linhas
17 KiB
/**
|
|
* Copyright 2009 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS-IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
const Changeset = require('ep_etherpad-lite/static/js/Changeset');
|
|
const padManager = require('../db/PadManager');
|
|
const _ = require('underscore');
|
|
const Security = require('ep_etherpad-lite/static/js/security');
|
|
const hooks = require('ep_etherpad-lite/static/js/pluginfw/hooks');
|
|
const eejs = require('ep_etherpad-lite/node/eejs');
|
|
const _analyzeLine = require('./ExportHelper')._analyzeLine;
|
|
const _encodeWhitespace = require('./ExportHelper')._encodeWhitespace;
|
|
const padutils = require('../../static/js/pad_utils').padutils;
|
|
|
|
async function getPadHTML(pad, revNum) {
|
|
let atext = pad.atext;
|
|
|
|
// fetch revision atext
|
|
if (revNum != undefined) {
|
|
atext = await pad.getInternalRevisionAText(revNum);
|
|
}
|
|
|
|
// convert atext to html
|
|
return await getHTMLFromAtext(pad, atext);
|
|
}
|
|
|
|
exports.getPadHTML = getPadHTML;
|
|
exports.getHTMLFromAtext = getHTMLFromAtext;
|
|
|
|
async function getHTMLFromAtext(pad, atext, authorColors) {
|
|
const apool = pad.apool();
|
|
const textLines = atext.text.slice(0, -1).split('\n');
|
|
const attribLines = Changeset.splitAttributionLines(atext.attribs, atext.text);
|
|
|
|
const tags = ['h1', 'h2', 'strong', 'em', 'u', 's'];
|
|
const props = ['heading1', 'heading2', 'bold', 'italic', 'underline', 'strikethrough'];
|
|
|
|
await Promise.all([
|
|
// prepare tags stored as ['tag', true] to be exported
|
|
hooks.aCallAll('exportHtmlAdditionalTags', pad).then((newProps) => {
|
|
newProps.forEach((prop) => {
|
|
tags.push(prop);
|
|
props.push(prop);
|
|
});
|
|
}),
|
|
// prepare tags stored as ['tag', 'value'] to be exported. This will generate HTML with tags
|
|
// like <span data-tag="value">
|
|
hooks.aCallAll('exportHtmlAdditionalTagsWithData', pad).then((newProps) => {
|
|
newProps.forEach((prop) => {
|
|
tags.push(`span data-${prop[0]}="${prop[1]}"`);
|
|
props.push(prop);
|
|
});
|
|
}),
|
|
]);
|
|
|
|
// holds a map of used styling attributes (*1, *2, etc) in the apool
|
|
// and maps them to an index in props
|
|
// *3:2 -> the attribute *3 means strong
|
|
// *2:5 -> the attribute *2 means s(trikethrough)
|
|
const anumMap = {};
|
|
let css = '';
|
|
|
|
const stripDotFromAuthorID = function (id) {
|
|
return id.replace(/\./g, '_');
|
|
};
|
|
|
|
if (authorColors) {
|
|
css += '<style>\n';
|
|
|
|
for (const a in apool.numToAttrib) {
|
|
const attr = apool.numToAttrib[a];
|
|
|
|
// skip non author attributes
|
|
if (attr[0] === 'author' && attr[1] !== '') {
|
|
// add to props array
|
|
var propName = `author${stripDotFromAuthorID(attr[1])}`;
|
|
var newLength = props.push(propName);
|
|
anumMap[a] = newLength - 1;
|
|
|
|
css += `.${propName} {background-color: ${authorColors[attr[1]]}}\n`;
|
|
} else if (attr[0] === 'removed') {
|
|
var propName = 'removed';
|
|
|
|
var newLength = props.push(propName);
|
|
anumMap[a] = newLength - 1;
|
|
|
|
css += '.removed {text-decoration: line-through; ' +
|
|
"-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=80)'; " +
|
|
'filter: alpha(opacity=80); ' +
|
|
'opacity: 0.8; ' +
|
|
'}\n';
|
|
}
|
|
}
|
|
|
|
css += '</style>';
|
|
}
|
|
|
|
// iterates over all props(h1,h2,strong,...), checks if it is used in
|
|
// this pad, and if yes puts its attrib id->props value into anumMap
|
|
props.forEach((propName, i) => {
|
|
let attrib = [propName, true];
|
|
if (_.isArray(propName)) {
|
|
// propName can be in the form of ['color', 'red'],
|
|
// see hook exportHtmlAdditionalTagsWithData
|
|
attrib = propName;
|
|
}
|
|
const propTrueNum = apool.putAttrib(attrib, true);
|
|
if (propTrueNum >= 0) {
|
|
anumMap[propTrueNum] = i;
|
|
}
|
|
});
|
|
|
|
function getLineHTML(text, attribs) {
|
|
// Use order of tags (b/i/u) as order of nesting, for simplicity
|
|
// and decent nesting. For example,
|
|
// <b>Just bold<b> <b><i>Bold and italics</i></b> <i>Just italics</i>
|
|
// becomes
|
|
// <b>Just bold <i>Bold and italics</i></b> <i>Just italics</i>
|
|
const taker = Changeset.stringIterator(text);
|
|
const assem = Changeset.stringAssembler();
|
|
const openTags = [];
|
|
|
|
function getSpanClassFor(i) {
|
|
// return if author colors are disabled
|
|
if (!authorColors) return false;
|
|
|
|
const property = props[i];
|
|
|
|
// we are not insterested on properties in the form of ['color', 'red'],
|
|
// see hook exportHtmlAdditionalTagsWithData
|
|
if (_.isArray(property)) {
|
|
return false;
|
|
}
|
|
|
|
if (property.substr(0, 6) === 'author') {
|
|
return stripDotFromAuthorID(property);
|
|
}
|
|
|
|
if (property === 'removed') {
|
|
return 'removed';
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// tags added by exportHtmlAdditionalTagsWithData will be exported as <span> with
|
|
// data attributes
|
|
function isSpanWithData(i) {
|
|
const property = props[i];
|
|
return _.isArray(property);
|
|
}
|
|
|
|
function emitOpenTag(i) {
|
|
openTags.unshift(i);
|
|
const spanClass = getSpanClassFor(i);
|
|
|
|
if (spanClass) {
|
|
assem.append('<span class="');
|
|
assem.append(spanClass);
|
|
assem.append('">');
|
|
} else {
|
|
assem.append('<');
|
|
assem.append(tags[i]);
|
|
assem.append('>');
|
|
}
|
|
}
|
|
|
|
// this closes an open tag and removes its reference from openTags
|
|
function emitCloseTag(i) {
|
|
openTags.shift();
|
|
const spanClass = getSpanClassFor(i);
|
|
const spanWithData = isSpanWithData(i);
|
|
|
|
if (spanClass || spanWithData) {
|
|
assem.append('</span>');
|
|
} else {
|
|
assem.append('</');
|
|
assem.append(tags[i]);
|
|
assem.append('>');
|
|
}
|
|
}
|
|
|
|
const urls = padutils.findURLs(text);
|
|
|
|
let idx = 0;
|
|
|
|
function processNextChars(numChars) {
|
|
if (numChars <= 0) {
|
|
return;
|
|
}
|
|
|
|
const iter = Changeset.opIterator(Changeset.subattribution(attribs, idx, idx + numChars));
|
|
idx += numChars;
|
|
|
|
// this iterates over every op string and decides which tags to open or to close
|
|
// based on the attribs used
|
|
while (iter.hasNext()) {
|
|
const o = iter.next();
|
|
var usedAttribs = [];
|
|
|
|
// mark all attribs as used
|
|
Changeset.eachAttribNumber(o.attribs, (a) => {
|
|
if (a in anumMap) {
|
|
usedAttribs.push(anumMap[a]); // i = 0 => bold, etc.
|
|
}
|
|
});
|
|
let outermostTag = -1;
|
|
// find the outer most open tag that is no longer used
|
|
for (var i = openTags.length - 1; i >= 0; i--) {
|
|
if (usedAttribs.indexOf(openTags[i]) === -1) {
|
|
outermostTag = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// close all tags upto the outer most
|
|
if (outermostTag !== -1) {
|
|
while (outermostTag >= 0) {
|
|
emitCloseTag(openTags[0]);
|
|
outermostTag--;
|
|
}
|
|
}
|
|
|
|
// open all tags that are used but not open
|
|
for (i = 0; i < usedAttribs.length; i++) {
|
|
if (openTags.indexOf(usedAttribs[i]) === -1) {
|
|
emitOpenTag(usedAttribs[i]);
|
|
}
|
|
}
|
|
|
|
let chars = o.chars;
|
|
if (o.lines) {
|
|
chars--; // exclude newline at end of line, if present
|
|
}
|
|
|
|
let s = taker.take(chars);
|
|
|
|
// removes the characters with the code 12. Don't know where they come
|
|
// from but they break the abiword parser and are completly useless
|
|
s = s.replace(String.fromCharCode(12), '');
|
|
|
|
assem.append(_encodeWhitespace(Security.escapeHTML(s)));
|
|
} // end iteration over spans in line
|
|
|
|
// close all the tags that are open after the last op
|
|
while (openTags.length > 0) {
|
|
emitCloseTag(openTags[0]);
|
|
}
|
|
} // end processNextChars
|
|
if (urls) {
|
|
urls.forEach((urlData) => {
|
|
const startIndex = urlData[0];
|
|
const url = urlData[1];
|
|
const urlLength = url.length;
|
|
processNextChars(startIndex - idx);
|
|
// Using rel="noreferrer" stops leaking the URL/location of the exported HTML when clicking links in the document.
|
|
// Not all browsers understand this attribute, but it's part of the HTML5 standard.
|
|
// https://html.spec.whatwg.org/multipage/links.html#link-type-noreferrer
|
|
// Additionally, we do rel="noopener" to ensure a higher level of referrer security.
|
|
// https://html.spec.whatwg.org/multipage/links.html#link-type-noopener
|
|
// https://mathiasbynens.github.io/rel-noopener/
|
|
// https://github.com/ether/etherpad-lite/pull/3636
|
|
assem.append(`<a href="${Security.escapeHTMLAttribute(url)}" rel="noreferrer noopener">`);
|
|
processNextChars(urlLength);
|
|
assem.append('</a>');
|
|
});
|
|
}
|
|
processNextChars(text.length - idx);
|
|
|
|
return _processSpaces(assem.toString());
|
|
} // end getLineHTML
|
|
const pieces = [css];
|
|
|
|
// Need to deal with constraints imposed on HTML lists; can
|
|
// only gain one level of nesting at once, can't change type
|
|
// mid-list, etc.
|
|
// People might use weird indenting, e.g. skip a level,
|
|
// so we want to do something reasonable there. We also
|
|
// want to deal gracefully with blank lines.
|
|
// => keeps track of the parents level of indentation
|
|
let openLists = [];
|
|
for (let i = 0; i < textLines.length; i++) {
|
|
var context;
|
|
var line = _analyzeLine(textLines[i], attribLines[i], apool);
|
|
const lineContent = getLineHTML(line.text, line.aline);
|
|
if (line.listLevel)// If we are inside a list
|
|
{
|
|
context = {
|
|
line,
|
|
lineContent,
|
|
apool,
|
|
attribLine: attribLines[i],
|
|
text: textLines[i],
|
|
padId: pad.id,
|
|
};
|
|
let prevLine = null;
|
|
let nextLine = null;
|
|
if (i > 0) {
|
|
prevLine = _analyzeLine(textLines[i - 1], attribLines[i - 1], apool);
|
|
}
|
|
if (i < textLines.length) {
|
|
nextLine = _analyzeLine(textLines[i + 1], attribLines[i + 1], apool);
|
|
}
|
|
await hooks.aCallAll('getLineHTMLForExport', context);
|
|
// To create list parent elements
|
|
if ((!prevLine || prevLine.listLevel !== line.listLevel) || (prevLine && line.listTypeName !== prevLine.listTypeName)) {
|
|
const exists = _.find(openLists, (item) => (item.level === line.listLevel && item.type === line.listTypeName));
|
|
if (!exists) {
|
|
let prevLevel = 0;
|
|
if (prevLine && prevLine.listLevel) {
|
|
prevLevel = prevLine.listLevel;
|
|
}
|
|
if (prevLine && line.listTypeName !== prevLine.listTypeName) {
|
|
prevLevel = 0;
|
|
}
|
|
|
|
for (var diff = prevLevel; diff < line.listLevel; diff++) {
|
|
openLists.push({level: diff, type: line.listTypeName});
|
|
const prevPiece = pieces[pieces.length - 1];
|
|
|
|
if (prevPiece.indexOf('<ul') === 0 || prevPiece.indexOf('<ol') === 0 || prevPiece.indexOf('</li>') === 0) {
|
|
/*
|
|
uncommenting this breaks nested ols..
|
|
if the previous item is NOT a ul, NOT an ol OR closing li then close the list
|
|
so we consider this HTML, I inserted ** where it throws a problem in Example Wrong..
|
|
<ol><li>one</li><li><ol><li>1.1</li><li><ol><li>1.1.1</li></ol></li></ol></li><li>two</li></ol>
|
|
|
|
Note that closing the li then re-opening for another li item here is wrong. The correct markup is
|
|
<ol><li>one<ol><li>1.1<ol><li>1.1.1</li></ol></li></ol></li><li>two</li></ol>
|
|
|
|
Exmaple Right: <ol class="number"><li>one</li><ol start="2" class="number"><li>1.1</li><ol start="3" class="number"><li>1.1.1</li></ol></li></ol><li>two</li></ol>
|
|
Example Wrong: <ol class="number"><li>one</li>**</li>**<ol start="2" class="number"><li>1.1</li>**</li>**<ol start="3" class="number"><li>1.1.1</li></ol></li></ol><li>two</li></ol>
|
|
So it's firing wrong where the current piece is an li and the previous piece is an ol and next piece is an ol
|
|
So to remedy this we can say if next piece is NOT an OL or UL.
|
|
// pieces.push("</li>");
|
|
|
|
*/
|
|
if ((nextLine.listTypeName === 'number') && (nextLine.text === '')) {
|
|
// is the listTypeName check needed here? null text might be completely fine!
|
|
// TODO Check against Uls
|
|
// don't do anything because the next item is a nested ol openener so we need to keep the li open
|
|
} else {
|
|
pieces.push('<li>');
|
|
}
|
|
}
|
|
|
|
if (line.listTypeName === 'number') {
|
|
// We introduce line.start here, this is useful for continuing Ordered list line numbers
|
|
// in case you have a bullet in a list IE you Want
|
|
// 1. hello
|
|
// * foo
|
|
// 2. world
|
|
// Without this line.start logic it would be
|
|
// 1. hello * foo 1. world because the bullet would kill the OL
|
|
|
|
// TODO: This logic could also be used to continue OL with indented content
|
|
// but that's a job for another day....
|
|
if (line.start) {
|
|
pieces.push(`<ol start="${Number(line.start)}" class="${line.listTypeName}">`);
|
|
} else {
|
|
pieces.push(`<ol class="${line.listTypeName}">`);
|
|
}
|
|
} else {
|
|
pieces.push(`<ul class="${line.listTypeName}">`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// if we're going up a level we shouldn't be adding..
|
|
if (context.lineContent) {
|
|
pieces.push('<li>', context.lineContent);
|
|
}
|
|
|
|
// To close list elements
|
|
if (nextLine && nextLine.listLevel === line.listLevel && line.listTypeName === nextLine.listTypeName) {
|
|
if (context.lineContent) {
|
|
if ((nextLine.listTypeName === 'number') && (nextLine.text === '')) {
|
|
// is the listTypeName check needed here? null text might be completely fine!
|
|
// TODO Check against Uls
|
|
// don't do anything because the next item is a nested ol openener so we need to keep the li open
|
|
} else {
|
|
pieces.push('</li>');
|
|
}
|
|
}
|
|
}
|
|
if ((!nextLine || !nextLine.listLevel || nextLine.listLevel < line.listLevel) || (nextLine && line.listTypeName !== nextLine.listTypeName)) {
|
|
let nextLevel = 0;
|
|
if (nextLine && nextLine.listLevel) {
|
|
nextLevel = nextLine.listLevel;
|
|
}
|
|
if (nextLine && line.listTypeName !== nextLine.listTypeName) {
|
|
nextLevel = 0;
|
|
}
|
|
|
|
for (var diff = nextLevel; diff < line.listLevel; diff++) {
|
|
openLists = openLists.filter((el) => el.level !== diff && el.type !== line.listTypeName);
|
|
|
|
if (pieces[pieces.length - 1].indexOf('</ul') === 0 || pieces[pieces.length - 1].indexOf('</ol') === 0) {
|
|
pieces.push('</li>');
|
|
}
|
|
|
|
if (line.listTypeName === 'number') {
|
|
pieces.push('</ol>');
|
|
} else {
|
|
pieces.push('</ul>');
|
|
}
|
|
}
|
|
}
|
|
} else// outside any list, need to close line.listLevel of lists
|
|
{
|
|
context = {
|
|
line,
|
|
lineContent,
|
|
apool,
|
|
attribLine: attribLines[i],
|
|
text: textLines[i],
|
|
padId: pad.id,
|
|
};
|
|
|
|
await hooks.aCallAll('getLineHTMLForExport', context);
|
|
pieces.push(context.lineContent, '<br>');
|
|
}
|
|
}
|
|
|
|
return pieces.join('');
|
|
}
|
|
|
|
exports.getPadHTMLDocument = async function (padId, revNum) {
|
|
const pad = await padManager.getPad(padId);
|
|
|
|
// Include some Styles into the Head for Export
|
|
let stylesForExportCSS = '';
|
|
const stylesForExport = await hooks.aCallAll('stylesForExport', padId);
|
|
stylesForExport.forEach((css) => {
|
|
stylesForExportCSS += css;
|
|
});
|
|
|
|
let html = await getPadHTML(pad, revNum);
|
|
|
|
for (const hookHtml of await hooks.aCallAll('exportHTMLAdditionalContent', {padId})) {
|
|
html += hookHtml;
|
|
}
|
|
|
|
return eejs.require('ep_etherpad-lite/templates/export_html.html', {
|
|
body: html,
|
|
padId: Security.escapeHTML(padId),
|
|
extraCSS: stylesForExportCSS,
|
|
});
|
|
};
|
|
|
|
// copied from ACE
|
|
function _processSpaces(s) {
|
|
const doesWrap = true;
|
|
if (s.indexOf('<') < 0 && !doesWrap) {
|
|
// short-cut
|
|
return s.replace(/ /g, ' ');
|
|
}
|
|
const parts = [];
|
|
s.replace(/<[^>]*>?| |[^ <]+/g, (m) => {
|
|
parts.push(m);
|
|
});
|
|
if (doesWrap) {
|
|
let endOfLine = true;
|
|
let beforeSpace = false;
|
|
// last space in a run is normal, others are nbsp,
|
|
// end of line is nbsp
|
|
for (var i = parts.length - 1; i >= 0; i--) {
|
|
var p = parts[i];
|
|
if (p == ' ') {
|
|
if (endOfLine || beforeSpace) parts[i] = ' ';
|
|
endOfLine = false;
|
|
beforeSpace = true;
|
|
} else if (p.charAt(0) != '<') {
|
|
endOfLine = false;
|
|
beforeSpace = false;
|
|
}
|
|
}
|
|
// beginning of line is nbsp
|
|
for (i = 0; i < parts.length; i++) {
|
|
p = parts[i];
|
|
if (p == ' ') {
|
|
parts[i] = ' ';
|
|
break;
|
|
} else if (p.charAt(0) != '<') {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for (i = 0; i < parts.length; i++) {
|
|
p = parts[i];
|
|
if (p == ' ') {
|
|
parts[i] = ' ';
|
|
}
|
|
}
|
|
}
|
|
return parts.join('');
|
|
}
|