repo/sceditor: src/formats/bbcode.js comparison

comparison src/formats/bbcode.js @ 35:cd02cd04bc9d

fix [img]

author	Franklin Schmidt <fschmidt@gmail.com>
date	Mon, 15 Aug 2022 22:57:06 -0600
parents	20d1f23225fe
children	21090996a131

comparison

equal deleted inserted replaced

-:20d1f23225fe
+:cd02cd04bc9d
 				getEditorCommand('image')._dropDown(
 					editor,
 					caller,
 					selected,
 					function (url, width, height) {
-						var attrs  = '';
+						if( width || height ) {
+							editor.insertText(
-						if (width) {
+								'[img=' + width + 'x' + height + ']' + url + '[/img]'
-							attrs += ' width=' + width;
+							);
+						} else {
+							editor.insertText(
+								'[img]' + url + '[/img]'
+							);
 						}
-						if (height) {
-							attrs += ' height=' + height;
-						}
-						editor.insertText(
-							'[img' + attrs + ']' + url + '[/img]'
-						);
 					}
 				);
 			}
 		},
 		email: {
 				}
 				return '[font=' + _stripQuotes(font) + ']' +
 					content + '[/font]';
 			},
-			html: '<font face="{defaultattr}">{0}</font>'
+			html: '<font face="{attrib}">{0}</font>'
 		},
 		// END_COMMAND
 		// START_COMMAND: Size
 		size: {
 					size = fontSize;
 				}
 				return '[size=' + size + ']' + content + '[/size]';
 			},
-			html: '<font size="{defaultattr}">{!0}</font>'
+			html: '<font size="{attrib}">{!0}</font>'
 		},
 		// END_COMMAND
 		// START_COMMAND: Color
 		color: {
 				}
 				return '[color=' + _normaliseColour(color) + ']' +
 					content + '[/color]';
 			},
-			html: function (token, attrs, content) {
+			html: function (token, attrib, content) {
 				return '<font color="' +
-					escapeEntities(_normaliseColour(attrs.defaultattr), true) +
+					escapeEntities(_normaliseColour(attrib), true) +
 					'">' + content + '</font>';
 			}
 		},
 		// END_COMMAND
 				}
 			},
 			format: function (element, content) {
 				return attr(element, EMOTICON_DATA_ATTR) + content;
 			},
-			html: function (token, attrs, content, editor) {
+			html: function (token, attrib, content, editor) {
 				return editor.allEmoticons[content] || token.val + content + token.closing.val;
 			}
 		},
 		// END_COMMAND
 				// only add width and height if one is specified
 				if ((element.complete && (width || height)) ||
 					(width && height)) {
-					attribs = '=' + dom.width(element) + 'x' +
+					attribs = '=' + width + 'x' +
-						dom.height(element);
+						height;
 				}
 				return '[img' + attribs + ']' + attr(element, 'src') + '[/img]';
 			},
-			html: function (token, attrs, content) {
+			html: function (token, attrib, content) {
 				var	undef, width, height, match,
 					attribs = '';
-				// handle [img width=340 height=240]url[/img]
-				width  = attrs.width;
-				height = attrs.height;
 				// handle [img=340x240]url[/img]
-				if (attrs.defaultattr) {
+				if (attrib) {
-					match = attrs.defaultattr.split(/x/i);
+					match = attrib.split(/x/i);
 					width  = match[0];
-					height = (match.length === 2 ? match[1] : match[0]);
+					height = match[1];
 				}
-				if (width !== undef) {
+				if (width) {
 					attribs += ' width="' + escapeEntities(width, true) + '"';
 				}
-				if (height !== undef) {
+				if (height) {
 					attribs += ' height="' + escapeEntities(height, true) + '"';
 				}
 				return '<img' + attribs +
 					' src="' + escapeUriScheme(content) + '" />';
 					return '[url]' + content + '[/url]';
 				} else {
 					return '[url=' + url + ']' + content + '[/url]';
 				}
 			},
-			html: function (token, attrs, content) {
+			html: function (token, attrib, content) {
-				attrs.defaultattr =
+				attrib =
-					escapeEntities(attrs.defaultattr, true) || content;
+					escapeEntities(attrib, true) || content;
-				return '<a href="' + escapeUriScheme(attrs.defaultattr) + '">' +
+				return '<a href="' + escapeUriScheme(attrib) + '">' +
 					content + '</a>';
 			}
 		},
 		// END_COMMAND
 		// START_COMMAND: E-mail
 		email: {
 			quoteType: QuoteType.never,
-			html: function (token, attrs, content) {
+			html: function (token, attrib, content) {
 				return '<a href="mailto:' +
-					(escapeEntities(attrs.defaultattr, true) || content) +
+					(escapeEntities(attrib, true) || content) +
 					'">' + content + '</a>';
 			}
 		},
 		// END_COMMAND
 					}
 				}
 				return '[quote' + author + ']' + content + '[/quote]';
 			},
-			html: function (token, attrs, content) {
+			html: function (token, attrib, content) {
-				if (attrs.defaultattr) {
+				if (attrib) {
-					content = '<cite>' + escapeEntities(attrs.defaultattr) +
+					content = '<cite>' + escapeEntities(attrib) +
 						'</cite>' + content;
 				}
 				return '<blockquote>' + content + '</blockquote>';
 			}
 	/*
 	 * @typedef {Object} TokenizeToken
 	 * @property {string} type
 	 * @property {string} name
 	 * @property {string} val
-	 * @property {Object.<string, string>} attrs
+	 * @property {string} attrib
 	 * @property {array} children
 	 * @property {TokenizeToken} closing
 	 */
 	/**
 	 *
 	 * @param  {string} type The type of token this is,
 	 *                       should be one of tokenType
 	 * @param  {string} name The name of this token
 	 * @param  {string} val The originally matched string
-	 * @param  {array} attrs Any attributes. Only set on
+	 * @param  {string} attrib Any attributes. Only set on
 	 *                       TOKEN_TYPE_OPEN tokens
 	 * @param  {array} children Any children of this token
 	 * @param  {TokenizeToken} closing This tokens closing tag.
 	 *                                 Only set on TOKEN_TYPE_OPEN tokens
 	 * @class {TokenizeToken}
 	 * @name {TokenizeToken}
 	 * @memberOf BBCodeParser.prototype
 	 */
 	// eslint-disable-next-line max-params
-	function TokenizeToken(type, name, val, attrs, children, closing) {
+	function TokenizeToken(type, name, val, attrib, children, closing) {
 		var base      = this;
 		base.type     = type;
 		base.name     = name;
 		base.val      = val;
-		base.attrs    = attrs || {};
+		base.attrib   = attrib;
 		base.children = children || [];
 		base.closing  = closing || null;
 	};
 	TokenizeToken.prototype = {
 			return new TokenizeToken(
 				base.type,
 				base.name,
 				base.val,
-				extend({}, base.attrs),
+				base.attrib,
 				[],
 				base.closing ? base.closing.clone() : null
 			);
 		},
 		/**
 		 * @param {string} val
 		 * @return {Object}
 		 * @private
 		 */
 		function tokenizeTag(type, val) {
-			var matches, attrs, name,
+			var matches, attrib, name,
-				openRegex  = /\[([^\]\s=]+)(?:([^\]]+))?\]/,
+				openRegex  = /\[([^\]\s=]+)(?:=([^\]]+))?\]/,
 				closeRegex = /\[\/([^\[\]]+)\]/;
 			// Extract the name and attributes from opening tags and
 			// just the name from closing tags.
 			if (type === TOKEN_OPEN && (matches = val.match(openRegex))) {
 				name = lower(matches[1]);
 				if (matches[2] && (matches[2] = matches[2].trim())) {
-					attrs = tokenizeAttrs(matches[2]);
+					attrib = _stripQuotes(matches[2]);
 				}
 			}
 			if (type === TOKEN_CLOSE &&
 				(matches = val.match(closeRegex))) {
 				type = TOKEN_CONTENT;
 				name = '#';
 			}
-			return new TokenizeToken(type, name, val, attrs);
+			return new TokenizeToken(type, name, val, attrib);
-		}
-		/**
-		 * Extracts the individual attributes from a string containing
-		 * all the attributes.
-		 *
-		 * @param {string} attrs
-		 * @return {Object} Assoc array of attributes
-		 * @private
-		 */
-		function tokenizeAttrs(attrs) {
-			var	matches,
-				/*
-				([^\s=]+)				Anything that's not a space or equals
-				=						Equals sign =
-				(?:
-					(?:
-						(["'])					The opening quote
-						(
-							(?:\\\2|[^\2])*?	Anything that isn't the
-												unescaped opening quote
-						)
-						\2						The opening quote again which
-												will close the string
-					)
-						|				If not a quoted string then match
-					(
-						(?:.(?!\s\S+=))*.?		Anything that isn't part of
-												[space][non-space][=] which
-												would be a new attribute
-					)
-				)
-				*/
-				attrRegex = /([^\s=]+)=(?:(?:(["'])((?:\\\2|[^\2])*?)\2)|((?:.(?!\s\S+=))*.))/g,
-				ret       = {};
-			// if only one attribute then remove the = from the start and
-			// strip any quotes
-			if (attrs.charAt(0) === '=' && attrs.indexOf('=', 1) < 0) {
-				ret.defaultattr = _stripQuotes(attrs.substr(1));
-			} else {
-				if (attrs.charAt(0) === '=') {
-					attrs = 'defaultattr' + attrs;
-				}
-				// No need to strip quotes here, the regex will do that.
-				while ((matches = attrRegex.exec(attrs))) {
-					ret[lower(matches[1])] =
-						_stripQuotes(matches[3]) || matches[4];
-				}
-			}
-			return ret;
 		}
 		/**
 		 * Parses a string into an array of BBCodes
 		 *
 							// elements
 							content += '<br />';
 						}
 						if (!isFunction(bbcode.html)) {
-							token.attrs['0'] = content;
+							token['0'] = content;
 							html = formatBBCodeString(
 								bbcode.html,
-								token.attrs
+								token
 							);
 						} else {
 							html = bbcode.html(
 								token,
-								token.attrs,
+								token.attrib,
 								content,
 								editor
 							);
 						}
 					} else {
 						ret += '\n';
 					}
 					// Convert the tag and it's attributes to BBCode
 					ret += '[' + token.name;
-					if (token.attrs) {
+					if (token.attrib) {
-						if (token.attrs.defaultattr) {
+						ret += '=' + quote(
-							ret += '=' + quote(
+							token.attrib,
-								token.attrs.defaultattr,
+							quoteType
-								quoteType,
+						);
-								'defaultattr'
+						delete token.attrib;
-							);
-							delete token.attrs.defaultattr;
-						}
-						for (attr in token.attrs) {
-							if (token.attrs.hasOwnProperty(attr)) {
-								ret += ' ' + attr + '=' +
-									quote(token.attrs[attr], quoteType, attr);
-							}
-						}
 					}
 					ret += ']';
 					if (breakStart) {
 						ret += '\n';
 		 * @param {BBCodeParser.QuoteType} quoteType
 		 * @param {string} name
 		 * @return {string}
 		 * @private
 		 */
-		function quote(str, quoteType, name) {
+		function quote(str, quoteType) {
 			var	needsQuotes = /\s|=/.test(str);
 			if (isFunction(quoteType)) {
-				return quoteType(str, name);
+				return quoteType(str);
 			}
 			if (quoteType === QuoteType.never ||
 				(quoteType === QuoteType.auto && !needsQuotes)) {
 				return str;