Mercurial Hosting > sceditor
view src/formats/xhtml.js @ 47:16b61f228546 default tip
minor
author | Franklin Schmidt <fschmidt@gmail.com> |
---|---|
date | Mon, 31 Oct 2022 10:41:24 -0600 |
parents | ab2dc8736d88 |
children |
line wrap: on
line source
/** * SCEditor XHTML Plugin * http://www.sceditor.com/ * * Copyright (C) 2017, Sam Clarke (samclarke.com) * * SCEditor is licensed under the MIT license: * http://www.opensource.org/licenses/mit-license.php * * @author Sam Clarke */ (function (sceditor) { 'use strict'; var dom = sceditor.dom; var utils = sceditor.utils; var css = dom.css; var attr = dom.attr; var is = dom.is; var removeAttr = dom.removeAttr; var convertElement = dom.convertElement; var extend = utils.extend; var extendDeep = utils.extendDeep; var each = utils.each; var isEmptyObject = utils.isEmptyObject; function getEditorCommand(cmd) { return sceditor.commands[cmd]; } var defaultCommandsOverrides = { bold: { txtExec: ['<strong>', '</strong>'] }, italic: { txtExec: ['<em>', '</em>'] }, underline: { txtExec: ['<span style="text-decoration:underline;">', '</span>'] }, strike: { txtExec: ['<span style="text-decoration:line-through;">', '</span>'] }, subscript: { txtExec: ['<sub>', '</sub>'] }, superscript: { txtExec: ['<sup>', '</sup>'] }, left: { txtExec: ['<div style="text-align:left;">', '</div>'] }, center: { txtExec: ['<div style="text-align:center;">', '</div>'] }, right: { txtExec: ['<div style="text-align:right;">', '</div>'] }, justify: { txtExec: ['<div style="text-align:justify;">', '</div>'] }, font: { txtExec: function (editor, caller) { getEditorCommand('font')._dropDown( editor, caller, function (font) { editor.insertText('<span style="font-family:' + font + ';">', '</span>'); } ); } }, size: { txtExec: function (editor, caller) { getEditorCommand('size')._dropDown( editor, caller, function (size) { editor.insertText('<span style="font-size:' + size + ';">', '</span>'); } ); } }, color: { txtExec: function (editor, caller) { getEditorCommand('color')._dropDown( editor, caller, function (color) { editor.insertText('<span style="color:' + color + ';">', '</span>'); } ); } }, bulletlist: { txtExec: ['<ul><li>', '</li></ul>'] }, orderedlist: { txtExec: ['<ol><li>', '</li></ol>'] }, table: { txtExec: ['<table><tr><td>', '</td></tr></table>'] }, horizontalrule: { txtExec: ['<hr />'] }, code: { txtExec: ['<code>', '</code>'] }, image: { txtExec: function (editor, caller, selected) { getEditorCommand('image')._dropDown( editor, caller, selected, function (url, width, height) { var attrs = ''; if (width) { attrs += ' width="' + width + '"'; } if (height) { attrs += ' height="' + height + '"'; } editor.insertText( '<img' + attrs + ' src="' + url + '" />' ); } ); } }, email: { txtExec: function (editor, caller, selected) { getEditorCommand('email')._dropDown( editor, caller, function (url, text) { editor.insertText( '<a href="mailto:' + url + '">' + (text || selected || url) + '</a>' ); } ); } }, link: { txtExec: function (editor, caller, selected) { getEditorCommand('link')._dropDown( editor, caller, function (url, text) { editor.insertText( '<a href="' + url + '">' + (text || selected || url) + '</a>' ); } ); } }, quote: { txtExec: ['<blockquote>', '</blockquote>'] }, youtube: { txtExec: function (editor, caller) { getEditorCommand('youtube')._dropDown( editor, caller, function (id, time) { editor.insertText( '<iframe width="560" height="315" ' + 'src="https://www.youtube.com/embed/{id}?' + 'wmode=opaque&start=' + time + '" ' + 'data-youtube-id="' + id + '" ' + 'frameborder="0" allowfullscreen></iframe>' ); } ); } }, rtl: { txtExec: ['<div stlye="direction:rtl;">', '</div>'] }, ltr: { txtExec: ['<div stlye="direction:ltr;">', '</div>'] } }; /** * XHTMLSerializer part of the XHTML plugin. * * @class XHTMLSerializer * @name jQuery.sceditor.XHTMLSerializer * @since v1.4.1 */ sceditor.XHTMLSerializer = function () { var base = this; var opts = { indentStr: '\t' }; /** * Array containing the output, used as it's faster * than string concatenation in slow browsers. * @type {Array} * @private */ var outputStringBuilder = []; /** * Current indention level * @type {number} * @private */ var currentIndent = 0; // TODO: use escape.entities /** * Escapes XHTML entities * * @param {string} str * @return {string} * @private */ function escapeEntities(str) { var entities = { '&': '&', '<': '<', '>': '>', '"': '"', '\xa0': ' ' }; return !str ? '' : str.replace(/[&<>"\xa0]/g, function (entity) { return entities[entity] || entity; }); }; /** * Replace spaces including newlines with a single * space except for non-breaking spaces * * @param {string} str * @return {string} * @private */ function trim(str) { return str.replace(/[^\S\u00A0]+/g, ' '); }; /** * Serializes a node to XHTML * * @param {Node} node Node to serialize * @param {boolean} onlyChildren If to only serialize the nodes * children and not the node * itself * @return {string} The serialized node * @name serialize * @memberOf jQuery.sceditor.XHTMLSerializer.prototype * @since v1.4.1 */ base.serialize = function (node, onlyChildren) { outputStringBuilder = []; if (onlyChildren) { node = node.firstChild; while (node) { serializeNode(node); node = node.nextSibling; } } else { serializeNode(node); } return outputStringBuilder.join(''); }; /** * Serializes a node to the outputStringBuilder * * @param {Node} node * @return {void} * @private */ function serializeNode(node, parentIsPre) { switch (node.nodeType) { case 1: // element handleElement(node, parentIsPre); break; case 3: // text handleText(node, parentIsPre); break; case 4: // cdata section handleCdata(node); break; case 8: // comment handleComment(node); break; case 9: // document case 11: // document fragment handleDoc(node); break; // Ignored types case 2: // attribute case 5: // entity ref case 6: // entity case 7: // processing instruction case 10: // document type case 12: // notation break; } }; /** * Handles doc node * @param {Node} node * @return {void} * @private */ function handleDoc(node) { var child = node.firstChild; while (child) { serializeNode(child); child = child.nextSibling; } }; /** * Handles element nodes * @param {Node} node * @return {void} * @private */ function handleElement(node, parentIsPre) { var child, attr, attrValue, tagName = node.nodeName.toLowerCase(), isIframe = tagName === 'iframe', attrIdx = node.attributes.length, firstChild = node.firstChild, // pre || pre-wrap with any vendor prefix isPre = parentIsPre || /pre(?:\-wrap)?$/i.test(css(node, 'whiteSpace')), selfClosing = !node.firstChild && !dom.canHaveChildren(node) && !isIframe; if (is(node, '.sceditor-ignore')) { return; } output('<' + tagName, !parentIsPre && canIndent(node)); while (attrIdx--) { attr = node.attributes[attrIdx]; attrValue = attr.value; output(' ' + attr.name.toLowerCase() + '="' + escapeEntities(attrValue) + '"', false); } output(selfClosing ? ' />' : '>', false); if (!isIframe) { child = firstChild; } while (child) { currentIndent++; serializeNode(child, isPre); child = child.nextSibling; currentIndent--; } if (!selfClosing) { output( '</' + tagName + '>', !isPre && !isIframe && canIndent(node) && firstChild && canIndent(firstChild) ); } }; /** * Handles CDATA nodes * @param {Node} node * @return {void} * @private */ function handleCdata(node) { output('<![CDATA[' + escapeEntities(node.nodeValue) + ']]>'); }; /** * Handles comment nodes * @param {Node} node * @return {void} * @private */ function handleComment(node) { output('<!-- ' + escapeEntities(node.nodeValue) + ' -->'); }; /** * Handles text nodes * @param {Node} node * @return {void} * @private */ function handleText(node, parentIsPre) { var text = node.nodeValue; if (!parentIsPre) { text = trim(text); } if (text) { output(escapeEntities(text), !parentIsPre && canIndent(node)); } }; /** * Adds a string to the outputStringBuilder. * * The string will be indented unless indent is set to boolean false. * @param {string} str * @param {boolean} indent * @return {void} * @private */ function output(str, indent) { var i = currentIndent; if (indent !== false) { // Don't add a new line if it's the first element if (outputStringBuilder.length) { outputStringBuilder.push('\n'); } while (i--) { outputStringBuilder.push(opts.indentStr); } } outputStringBuilder.push(str); }; /** * Checks if should indent the node or not * @param {Node} node * @return {boolean} * @private */ function canIndent(node) { var prev = node.previousSibling; if (node.nodeType !== 1 && prev) { return !dom.isInline(prev); } // first child of a block element if (!prev && !dom.isInline(node.parentNode)) { return true; } return !dom.isInline(node); }; }; /** * SCEditor XHTML plugin * @class xhtml * @name jQuery.sceditor.plugins.xhtml * @since v1.4.1 */ function xhtmlFormat() { var base = {}; /** * Tag converters cache * @type {Object} * @private */ var tagConvertersCache = {}; /** * Attributes filter cache * @type {Object} * @private */ var attrsCache = {}; /** * Init * @return {void} */ base.init = function (editor) { if (!isEmptyObject(xhtmlFormat.converters || {})) { each( xhtmlFormat.converters, function (idx, converter) { each(converter.tags, function (tagname) { if (!tagConvertersCache[tagname]) { tagConvertersCache[tagname] = []; } tagConvertersCache[tagname].push(converter); }); } ); } editor.commands = extendDeep({}, defaultCommandsOverrides, editor.commands); }; /** * Converts the WYSIWYG content to XHTML * * @param {boolean} isFragment * @param {string} html * @param {Document} context * @param {HTMLElement} [parent] * @return {string} * @memberOf jQuery.sceditor.plugins.xhtml.prototype */ function toSource(html, context, parent, asFragment) { var xhtml, container = context.createElement('div'); container.innerHTML = html; css(container, 'visibility', 'hidden'); context.body.appendChild(container); convertTags(container); removeTags(container); removeAttribs(container); if (!asFragment) { wrapInlines(container); } xhtml = (new sceditor.XHTMLSerializer()).serialize(container, true); context.body.removeChild(container); return xhtml; } base.toSource = toSource; /** * Runs all converters for the specified tagName * against the DOM node. * @param {string} tagName * @return {Node} node * @private */ function convertNode(tagName, node) { if (!tagConvertersCache[tagName]) { return; } tagConvertersCache[tagName].forEach(function (converter) { if (converter.tags[tagName]) { each(converter.tags[tagName], function (attr, values) { if (!node.getAttributeNode) { return; } attr = node.getAttributeNode(attr); if (!attr || values && values.indexOf(attr.value) < 0) { return; } converter.conv(node); }); } else if (converter.conv) { converter.conv(node); } }); }; /** * Converts any tags/attributes to their XHTML equivalents * @param {Node} node * @return {void} * @private */ function convertTags(node) { dom.traverse(node, function (node) { var tagName = node.nodeName.toLowerCase(); convertNode('*', node); convertNode(tagName, node); }, true); }; /** * Tests if a node is empty and can be removed. * * @param {Node} node * @return {boolean} * @private */ function isEmpty(node, excludeBr) { var rect, childNodes = node.childNodes, tagName = node.nodeName.toLowerCase(), nodeValue = node.nodeValue, childrenLength = childNodes.length, allowedEmpty = xhtmlFormat.allowedEmptyTags || []; if (excludeBr && tagName === 'br') { return true; } if (is(node, '.sceditor-ignore')) { return true; } if (allowedEmpty.indexOf(tagName) > -1 || tagName === 'td' || !dom.canHaveChildren(node)) { return false; } // \S|\u00A0 = any non space char if (nodeValue && /\S|\u00A0/.test(nodeValue)) { return false; } while (childrenLength--) { if (!isEmpty(childNodes[childrenLength], excludeBr && !node.previousSibling && !node.nextSibling)) { return false; } } // Treat tags with a width and height from CSS as not empty if (node.getBoundingClientRect && (node.className || node.hasAttributes('style'))) { rect = node.getBoundingClientRect(); return !rect.width || !rect.height; } return true; }; /** * Removes any tags that are not white listed or if no * tags are white listed it will remove any tags that * are black listed. * * @param {Node} rootNode * @return {void} * @private */ function removeTags(rootNode) { dom.traverse(rootNode, function (node) { var remove, tagName = node.nodeName.toLowerCase(), parentNode = node.parentNode, nodeType = node.nodeType, isBlock = !dom.isInline(node), previousSibling = node.previousSibling, nextSibling = node.nextSibling, isTopLevel = parentNode === rootNode, noSiblings = !previousSibling && !nextSibling, empty = tagName !== 'iframe' && isEmpty(node, isTopLevel && noSiblings && tagName !== 'br'), document = node.ownerDocument, allowedTags = xhtmlFormat.allowedTags, firstChild = node.firstChild, disallowedTags = xhtmlFormat.disallowedTags; // 3 = text node if (nodeType === 3) { return; } if (nodeType === 4) { tagName = '!cdata'; } else if (tagName === '!' || nodeType === 8) { tagName = '!comment'; } if (nodeType === 1) { // skip empty nlf elements (new lines automatically // added after block level elements like quotes) if (is(node, '.sceditor-nlf')) { if (!firstChild || (node.childNodes.length === 1 && /br/i.test(firstChild.nodeName))) { // Mark as empty,it will be removed by the next code empty = true; } else { node.classList.remove('sceditor-nlf'); if (!node.className) { removeAttr(node, 'class'); } } } } if (empty) { remove = true; // 3 is text node which do not get filtered } else if (allowedTags && allowedTags.length) { remove = (allowedTags.indexOf(tagName) < 0); } else if (disallowedTags && disallowedTags.length) { remove = (disallowedTags.indexOf(tagName) > -1); } if (remove) { if (!empty) { if (isBlock && previousSibling && dom.isInline(previousSibling)) { parentNode.insertBefore( document.createTextNode(' '), node); } // Insert all the childen after node while (node.firstChild) { parentNode.insertBefore(node.firstChild, nextSibling); } if (isBlock && nextSibling && dom.isInline(nextSibling)) { parentNode.insertBefore( document.createTextNode(' '), nextSibling); } } parentNode.removeChild(node); } }, true); }; /** * Merges two sets of attribute filters into one * * @param {Object} filtersA * @param {Object} filtersB * @return {Object} * @private */ function mergeAttribsFilters(filtersA, filtersB) { var ret = {}; if (filtersA) { ret = extend({}, ret, filtersA); } if (!filtersB) { return ret; } each(filtersB, function (attrName, values) { if (Array.isArray(values)) { ret[attrName] = (ret[attrName] || []).concat(values); } else if (!ret[attrName]) { ret[attrName] = null; } }); return ret; }; /** * Wraps adjacent inline child nodes of root * in paragraphs. * * @param {Node} root * @private */ function wrapInlines(root) { // Strip empty text nodes so they don't get wrapped. dom.removeWhiteSpace(root); var wrapper; var node = root.firstChild; var next; while (node) { next = node.nextSibling; if (dom.isInline(node) && !is(node, '.sceditor-ignore')) { if (!wrapper) { wrapper = root.ownerDocument.createElement('p'); node.parentNode.insertBefore(wrapper, node); } wrapper.appendChild(node); } else { wrapper = null; } node = next; } }; /** * Removes any attributes that are not white listed or * if no attributes are white listed it will remove * any attributes that are black listed. * @param {Node} node * @return {void} * @private */ function removeAttribs(node) { var tagName, attr, attrName, attrsLength, validValues, remove, allowedAttribs = xhtmlFormat.allowedAttribs, isAllowed = allowedAttribs && !isEmptyObject(allowedAttribs), disallowedAttribs = xhtmlFormat.disallowedAttribs, isDisallowed = disallowedAttribs && !isEmptyObject(disallowedAttribs); attrsCache = {}; dom.traverse(node, function (node) { if (!node.attributes) { return; } tagName = node.nodeName.toLowerCase(); attrsLength = node.attributes.length; if (attrsLength) { if (!attrsCache[tagName]) { if (isAllowed) { attrsCache[tagName] = mergeAttribsFilters( allowedAttribs['*'], allowedAttribs[tagName] ); } else { attrsCache[tagName] = mergeAttribsFilters( disallowedAttribs['*'], disallowedAttribs[tagName] ); } } while (attrsLength--) { attr = node.attributes[attrsLength]; attrName = attr.name; validValues = attrsCache[tagName][attrName]; remove = false; if (isAllowed) { remove = validValues !== null && (!Array.isArray(validValues) || validValues.indexOf(attr.value) < 0); } else if (isDisallowed) { remove = validValues === null || (Array.isArray(validValues) && validValues.indexOf(attr.value) > -1); } if (remove) { node.removeAttribute(attrName); } } } }); }; return base; }; /** * Tag conveters, a converter is applied to all * tags that match the criteria. * @type {Array} * @name jQuery.sceditor.plugins.xhtml.converters * @since v1.4.1 */ xhtmlFormat.converters = [ { tags: { '*': { width: null } }, conv: function (node) { css(node, 'width', attr(node, 'width')); removeAttr(node, 'width'); } }, { tags: { '*': { height: null } }, conv: function (node) { css(node, 'height', attr(node, 'height')); removeAttr(node, 'height'); } }, { tags: { 'li': { value: null } }, conv: function (node) { removeAttr(node, 'value'); } }, { tags: { '*': { text: null } }, conv: function (node) { css(node, 'color', attr(node, 'text')); removeAttr(node, 'text'); } }, { tags: { '*': { color: null } }, conv: function (node) { css(node, 'color', attr(node, 'color')); removeAttr(node, 'color'); } }, { tags: { '*': { face: null } }, conv: function (node) { css(node, 'fontFamily', attr(node, 'face')); removeAttr(node, 'face'); } }, { tags: { '*': { align: null } }, conv: function (node) { css(node, 'textAlign', attr(node, 'align')); removeAttr(node, 'align'); } }, { tags: { '*': { border: null } }, conv: function (node) { css(node, 'borderWidth', attr(node, 'border')); removeAttr(node, 'border'); } }, { tags: { applet: { name: null }, img: { name: null }, layer: { name: null }, map: { name: null }, object: { name: null }, param: { name: null } }, conv: function (node) { if (!attr(node, 'id')) { attr(node, 'id', attr(node, 'name')); } removeAttr(node, 'name'); } }, { tags: { '*': { vspace: null } }, conv: function (node) { css(node, 'marginTop', attr(node, 'vspace') - 0); css(node, 'marginBottom', attr(node, 'vspace') - 0); removeAttr(node, 'vspace'); } }, { tags: { '*': { hspace: null } }, conv: function (node) { css(node, 'marginLeft', attr(node, 'hspace') - 0); css(node, 'marginRight', attr(node, 'hspace') - 0); removeAttr(node, 'hspace'); } }, { tags: { 'hr': { noshade: null } }, conv: function (node) { css(node, 'borderStyle', 'solid'); removeAttr(node, 'noshade'); } }, { tags: { '*': { nowrap: null } }, conv: function (node) { css(node, 'whiteSpace', 'nowrap'); removeAttr(node, 'nowrap'); } }, { tags: { big: null }, conv: function (node) { css(convertElement(node, 'span'), 'fontSize', 'larger'); } }, { tags: { small: null }, conv: function (node) { css(convertElement(node, 'span'), 'fontSize', 'smaller'); } }, { tags: { b: null }, conv: function (node) { convertElement(node, 'strong'); } }, { tags: { u: null }, conv: function (node) { css(convertElement(node, 'span'), 'textDecoration', 'underline'); } }, { tags: { s: null, strike: null }, conv: function (node) { css(convertElement(node, 'span'), 'textDecoration', 'line-through'); } }, { tags: { dir: null }, conv: function (node) { convertElement(node, 'ul'); } }, { tags: { center: null }, conv: function (node) { css(convertElement(node, 'div'), 'textAlign', 'center'); } }, { tags: { font: { size: null } }, conv: function (node) { css(node, 'fontSize', css(node, 'fontSize')); removeAttr(node, 'size'); } }, { tags: { font: null }, conv: function (node) { // All it's attributes will be converted // by the attribute converters convertElement(node, 'span'); } }, { tags: { '*': { type: ['_moz'] } }, conv: function (node) { removeAttr(node, 'type'); } }, { tags: { '*': { '_moz_dirty': null } }, conv: function (node) { removeAttr(node, '_moz_dirty'); } }, { tags: { '*': { '_moz_editor_bogus_node': null } }, conv: function (node) { node.parentNode.removeChild(node); } }, { tags: { '*': { 'data-sce-target': null } }, conv: function (node) { var rel = attr(node, 'rel') || ''; var target = attr(node, 'data-sce-target'); // Only allow the value _blank and only on links if (target === '_blank' && is(node, 'a')) { if (!/(^|\s)noopener(\s|$)/.test(rel)) { attr(node, 'rel', 'noopener' + (rel ? ' ' + rel : '')); } attr(node, 'target', target); } removeAttr(node, 'data-sce-target'); } }, { tags: { code: null }, conv: function (node) { var node, nodes = node.getElementsByTagName('div'); while ((node = nodes[0])) { node.style.display = 'block'; convertElement(node, 'span'); } } } ]; /** * Allowed attributes map. * * To allow an attribute for all tags use * as the tag name. * * Leave empty or null to allow all attributes. (the disallow * list will be used to filter them instead) * @type {Object} * @name jQuery.sceditor.plugins.xhtml.allowedAttribs * @since v1.4.1 */ xhtmlFormat.allowedAttribs = {}; /** * Attributes that are not allowed. * * Only used if allowed attributes is null or empty. * @type {Object} * @name jQuery.sceditor.plugins.xhtml.disallowedAttribs * @since v1.4.1 */ xhtmlFormat.disallowedAttribs = {}; /** * Array containing all the allowed tags. * * If null or empty all tags will be allowed. * @type {Array} * @name jQuery.sceditor.plugins.xhtml.allowedTags * @since v1.4.1 */ xhtmlFormat.allowedTags = []; /** * Array containing all the disallowed tags. * * Only used if allowed tags is null or empty. * @type {Array} * @name jQuery.sceditor.plugins.xhtml.disallowedTags * @since v1.4.1 */ xhtmlFormat.disallowedTags = []; /** * Array containing tags which should not be removed when empty. * * @type {Array} * @name jQuery.sceditor.plugins.xhtml.allowedEmptyTags * @since v2.0.0 */ xhtmlFormat.allowedEmptyTags = []; sceditor.formats.xhtml = xhtmlFormat; sceditor.defaultOptions.format = 'xhtml'; }(sceditor));