@ckeditor/ckeditor5-html-support 34.1.0 → 35.0.1

package/src/integrations/customelement.js

@@ -0,0 +1,179 @@
+/**
+ * @license Copyright (c) 2003-2022, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+
+/**
+ * @module html-support/integrations/customelement
+ */
+
+/* globals document */
+
+import { Plugin } from 'ckeditor5/src/core';
+import { UpcastWriter } from 'ckeditor5/src/engine';
+
+import DataSchema from '../dataschema';
+import DataFilter from '../datafilter';
+import { setViewAttributes } from '../conversionutils';
+
+/**
+ * Provides the General HTML Support for custom elements (not registered in the {@link module:html-support/dataschema~DataSchema}).
+ *
+ * @extends module:core/plugin~Plugin
+ */
+export default class CustomElementSupport extends Plugin {
+	/**
+	 * @inheritDoc
+	 */
+	static get requires() {
+		return [ DataFilter, DataSchema ];
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'CustomElementSupport';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	init() {
+		const dataFilter = this.editor.plugins.get( DataFilter );
+		const dataSchema = this.editor.plugins.get( DataSchema );
+
+		dataFilter.on( 'register:$customElement', ( evt, definition ) => {
+			evt.stop();
+
+			const editor = this.editor;
+			const schema = editor.model.schema;
+			const conversion = editor.conversion;
+			const unsafeElements = editor.editing.view.domConverter.unsafeElements;
+			const preLikeElements = editor.data.htmlProcessor.domConverter.preElements;
+
+			schema.register( definition.model, definition.modelSchema );
+			schema.extend( definition.model, {
+				allowAttributes: [ 'htmlElementName', 'htmlAttributes', 'htmlContent' ],
+				isContent: true
+			} );
+
+			// Being executed on the low priority, it will catch all elements that were not caught by other converters.
+			conversion.for( 'upcast' ).elementToElement( {
+				view: /.*/,
+				model: ( viewElement, conversionApi ) => {
+					// Do not try to convert $comment fake element.
+					if ( viewElement.name == '$comment' ) {
+						return;
+					}
+
+					if ( !isValidElementName( viewElement.name ) ) {
+						return;
+					}
+
+					// Allow for fallback only if this element is not defined in data schema to make sure
+					// that this will handle only custom elements not registered in the data schema.
+					if ( dataSchema.getDefinitionsForView( viewElement.name ).size ) {
+						return;
+					}
+
+					// Make sure that this element will not render in the editing view.
+					if ( !unsafeElements.includes( viewElement.name ) ) {
+						unsafeElements.push( viewElement.name );
+					}
+
+					// Make sure that whitespaces will not be trimmed or replaced by nbsps while stringify content.
+					if ( !preLikeElements.includes( viewElement.name ) ) {
+						preLikeElements.push( viewElement.name );
+					}
+
+					const modelElement = conversionApi.writer.createElement( definition.model, {
+						htmlElementName: viewElement.name
+					} );
+
+					const htmlAttributes = dataFilter.processViewAttributes( viewElement, conversionApi );
+
+					if ( htmlAttributes ) {
+						conversionApi.writer.setAttribute( 'htmlAttributes', htmlAttributes, modelElement );
+					}
+
+					// Store the whole element in the attribute so that DomConverter will be able to use the pre like element context.
+					const viewWriter = new UpcastWriter( viewElement.document );
+					const documentFragment = viewWriter.createDocumentFragment( viewElement );
+					const htmlContent = editor.data.processor.toData( documentFragment );
+
+					conversionApi.writer.setAttribute( 'htmlContent', htmlContent, modelElement );
+
+					// Consume the content of the element.
+					for ( const { item } of editor.editing.view.createRangeIn( viewElement ) ) {
+						conversionApi.consumable.consume( item, { name: true } );
+					}
+
+					return modelElement;
+				},
+				converterPriority: 'low'
+			} );
+
+			// Because this element is unsafe (DomConverter#unsafeElements), it will render as a transparent <span> but it must
+			// be rendered anyway for the mapping between the model and the view to exist.
+			conversion.for( 'editingDowncast' ).elementToElement( {
+				model: {
+					name: definition.model,
+					attributes: [ 'htmlElementName', 'htmlAttributes', 'htmlContent' ]
+				},
+				view: ( modelElement, { writer } ) => {
+					const viewName = modelElement.getAttribute( 'htmlElementName' );
+					const viewElement = writer.createRawElement( viewName );
+
+					if ( modelElement.hasAttribute( 'htmlAttributes' ) ) {
+						setViewAttributes( writer, modelElement.getAttribute( 'htmlAttributes' ), viewElement );
+					}
+
+					return viewElement;
+				}
+			} );
+
+			conversion.for( 'dataDowncast' ).elementToElement( {
+				model: {
+					name: definition.model,
+					attributes: [ 'htmlElementName', 'htmlAttributes', 'htmlContent' ]
+				},
+				view: ( modelElement, { writer } ) => {
+					const viewName = modelElement.getAttribute( 'htmlElementName' );
+					const htmlContent = modelElement.getAttribute( 'htmlContent' );
+
+					const viewElement = writer.createRawElement( viewName, null, ( domElement, domConverter ) => {
+						domConverter.setContentOf( domElement, htmlContent );
+
+						// Unwrap the custom element content (it was stored in the attribute as the whole custom element).
+						// See the upcast conversion for the "htmlContent" attribute to learn more.
+						const customElement = domElement.firstChild;
+
+						customElement.remove();
+
+						while ( customElement.firstChild ) {
+							domElement.appendChild( customElement.firstChild );
+						}
+					} );
+
+					if ( modelElement.hasAttribute( 'htmlAttributes' ) ) {
+						setViewAttributes( writer, modelElement.getAttribute( 'htmlAttributes' ), viewElement );
+					}
+
+					return viewElement;
+				}
+			} );
+		} );
+	}
+}
+
+// Returns true if name is valid for a DOM element name.
+function isValidElementName( name ) {
+	try {
+		document.createElement( name );
+	} catch ( error ) {
+		return false;
+	}
+
+	return true;
+}

package/src/integrations/documentlist.js

@@ -26,6 +26,13 @@ export default class DocumentListElementSupport extends Plugin {
 		return [ DataFilter ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'DocumentListElementSupport';
+	}
+
 	/**
 	 * @inheritDoc
 	 */

package/src/integrations/dualcontent.js

@@ -43,6 +43,13 @@ export default class DualContentModelElementSupport extends Plugin {
 		return [ DataFilter ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'DualContentModelElementSupport';
+	}
+
 	/**
 	 * @inheritDoc
 	 */

package/src/integrations/heading.js

@@ -24,6 +24,13 @@ export default class HeadingElementSupport extends Plugin {
 		return [ DataSchema ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'HeadingElementSupport';
+	}
+
 	/**
 	 * @inheritDoc
 	 */

package/src/integrations/image.js

@@ -28,6 +28,13 @@ export default class ImageElementSupport extends Plugin {
 		return [ DataFilter ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'ImageElementSupport';
+	}
+
 	/**
 	 * @inheritDoc
 	 */

package/src/integrations/mediaembed.js

@@ -19,10 +19,23 @@ import { updateViewAttributes } from '../conversionutils.js';
  * @extends module:core/plugin~Plugin
  */
 export default class MediaEmbedElementSupport extends Plugin {
+	/**
+	 * @inheritDoc
+	 */
 	static get requires() {
 		return [ DataFilter ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'MediaEmbedElementSupport';
+	}
+
+	/**
+	 * @inheritDoc
+	 */
 	init() {
 		const editor = this.editor;
 

package/src/integrations/script.js

@@ -30,6 +30,13 @@ export default class ScriptElementSupport extends Plugin {
 		return [ DataFilter ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'ScriptElementSupport';
+	}
+
 	/**
 	 * @inheritDoc
 	 */

package/src/integrations/style.js

@@ -30,6 +30,13 @@ export default class StyleElementSupport extends Plugin {
 		return [ DataFilter ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'StyleElementSupport';
+	}
+
 	/**
 	 * @inheritDoc
 	 */

package/src/integrations/table.js

@@ -24,6 +24,13 @@ export default class TableElementSupport extends Plugin {
 		return [ DataFilter ];
 	}
 
+	/**
+	 * @inheritDoc
+	 */
+	static get pluginName() {
+		return 'TableElementSupport';
+	}
+
 	/**
 	 * @inheritDoc
 	 */

package/src/schemadefinitions.js

@@ -839,6 +839,14 @@ export default {
 				allowWhere: [ '$text', '$block' ],
 				isInline: true
 			}
+		},
+		{
+			model: 'htmlCustomElement',
+			view: '$customElement',
+			modelSchema: {
+				allowWhere: [ '$text', '$block' ],
+				isInline: true
+			}
 		}
 	]
 };