@ckeditor/ckeditor5-html-support 38.0.1 → 38.1.0

package/src/datafilter.js

@@ -11,6 +11,7 @@ import { CKEditorError, priorities, isValidAttributeName } from 'ckeditor5/src/u
 import { Widget } from 'ckeditor5/src/widget';
 import { viewToModelObjectConverter, toObjectWidgetConverter, createObjectView, viewToAttributeInlineConverter, attributeToViewInlineConverter, viewToModelBlockAttributeConverter, modelToViewBlockAttributeConverter } from './converters';
 import { default as DataSchema } from './dataschema';
+import { getHtmlAttributeName } from './utils';
 import { isPlainObject, pull as removeItemFromArray } from 'lodash-es';
 import '../theme/datafilter.css';
 /**
@@ -57,7 +58,8 @@ export default class DataFilter extends Plugin {
         this._coupledAttributes = null;
         this._registerElementsAfterInit();
         this._registerElementHandlers();
-        this._registerModelPostFixer();
+        this._registerCoupledAttributesPostFixer();
+        this._registerAssociatedHtmlAttributesPostFixer();
     }
     /**
      * @inheritDoc
@@ -215,7 +217,7 @@ export default class DataFilter extends Plugin {
             }, {
                 // With the highest priority listener we are able to register elements right before
                 // running data conversion.
-                priority: priorities.get('highest') + 1
+                priority: priorities.highest + 1
             });
         }
     }
@@ -237,7 +239,7 @@ export default class DataFilter extends Plugin {
             // * Make sure no other features hook into this event before GHS because otherwise the
             // downcast conversion (for these features) could run before GHS registered its converters
             // (https://github.com/ckeditor/ckeditor5/issues/11356).
-            priority: priorities.get('highest') + 1
+            priority: priorities.highest + 1
         });
     }
     /**
@@ -296,7 +298,7 @@ export default class DataFilter extends Plugin {
      * The `htmlA` attribute would stay in the model and would cause GHS to generate an `<a>` element.
      * This is incorrect from UX point of view, as the user wanted to remove the whole link (not only `href`).
      */
-    _registerModelPostFixer() {
+    _registerCoupledAttributesPostFixer() {
         const model = this.editor.model;
         model.document.registerPostFixer(writer => {
             const changes = model.document.differ.getChanges();
@@ -325,6 +327,57 @@ export default class DataFilter extends Plugin {
             return changed;
         });
     }
+    /**
+     * Removes `html*Attributes` attributes from incompatible elements.
+     *
+     * For example, consider the following HTML:
+     *
+     * ```html
+     * <heading2 htmlH2Attributes="...">foobar[]</heading2>
+     * ```
+     *
+     * Pressing `enter` creates a new `paragraph` element that inherits
+     * the `htmlH2Attributes` attribute from `heading2`.
+     *
+     * ```html
+     * <heading2 htmlH2Attributes="...">foobar</heading2>
+     * <paragraph htmlH2Attributes="...">[]</paragraph>
+     * ```
+     *
+     * This postfixer ensures that this doesn't happen, and that elements can
+     * only have `html*Attributes` associated with them,
+     * e.g.: `htmlPAttributes` for `<p>`, `htmlDivAttributes` for `<div>`, etc.
+     *
+     * With it enabled, pressing `enter` at the end of `<heading2>` will create
+     * a new paragraph without the `htmlH2Attributes` attribute.
+     *
+     * ```html
+     * <heading2 htmlH2Attributes="...">foobar</heading2>
+     * <paragraph>[]</paragraph>
+     * ```
+     */
+    _registerAssociatedHtmlAttributesPostFixer() {
+        const model = this.editor.model;
+        model.document.registerPostFixer(writer => {
+            const changes = model.document.differ.getChanges();
+            let changed = false;
+            for (const change of changes) {
+                if (change.type !== 'insert' || change.name === '$text') {
+                    continue;
+                }
+                for (const attr of change.attributes.keys()) {
+                    if (!attr.startsWith('html') || !attr.endsWith('Attributes')) {
+                        continue;
+                    }
+                    if (!model.schema.checkAttribute(change.name, attr)) {
+                        writer.removeAttribute(attr, change.position.nodeAfter);
+                        changed = true;
+                    }
+                }
+            }
+            return changed;
+        });
+    }
     /**
      * Collects the map of coupled attributes. The returned map is keyed by the feature attribute name
      * and coupled GHS attribute names are stored in the value array.
@@ -370,7 +423,7 @@ export default class DataFilter extends Plugin {
             return;
         }
         schema.extend(definition.model, {
-            allowAttributes: ['htmlAttributes', 'htmlContent']
+            allowAttributes: [getHtmlAttributeName(viewName), 'htmlContent']
         });
         // Store element content in special `$rawContent` custom property to
         // avoid editor's data filtering mechanism.
@@ -382,15 +435,14 @@ export default class DataFilter extends Plugin {
             model: viewToModelObjectConverter(definition),
             // With a `low` priority, `paragraph` plugin auto-paragraphing mechanism is executed. Make sure
             // this listener is called before it. If not, some elements will be transformed into a paragraph.
-            converterPriority: priorities.get('low') + 1
+            // `+ 2` is used to take priority over `_addDefaultH1Conversion` in the Heading plugin.
+            converterPriority: priorities.low + 2
         });
         conversion.for('upcast').add(viewToModelBlockAttributeConverter(definition, this));
         conversion.for('editingDowncast').elementToStructure({
             model: {
                 name: modelName,
-                attributes: [
-                    'htmlAttributes'
-                ]
+                attributes: [getHtmlAttributeName(viewName)]
             },
             view: toObjectWidgetConverter(editor, definition)
         });
@@ -420,7 +472,8 @@ export default class DataFilter extends Plugin {
                 view: viewName,
                 // With a `low` priority, `paragraph` plugin auto-paragraphing mechanism is executed. Make sure
                 // this listener is called before it. If not, some elements will be transformed into a paragraph.
-                converterPriority: priorities.get('low') + 1
+                // `+ 2` is used to take priority over `_addDefaultH1Conversion` in the Heading plugin.
+                converterPriority: priorities.low + 2
             });
             conversion.for('downcast').elementToElement({
                 model: modelName,
@@ -431,7 +484,7 @@ export default class DataFilter extends Plugin {
             return;
         }
         schema.extend(definition.model, {
-            allowAttributes: 'htmlAttributes'
+            allowAttributes: getHtmlAttributeName(viewName)
         });
         conversion.for('upcast').add(viewToModelBlockAttributeConverter(definition, this));
         conversion.for('downcast').add(modelToViewBlockAttributeConverter(definition));

package/src/dataschema.d.ts

@@ -47,7 +47,7 @@ export default class DataSchema extends Plugin {
     /**
      * @inheritDoc
      */
-    static get pluginName(): 'DataSchema';
+    static get pluginName(): "DataSchema";
     /**
      * @inheritDoc
      */
@@ -166,7 +166,7 @@ export interface DataSchemaInlineElementDefinition extends DataSchemaDefinition
     /**
      * The name of the model attribute that generates the same view element. GHS inline attribute
      * will be removed from the model tree as soon as the coupled attribute is removed. See
-     * {@link module:html-support/datafilter~DataFilter#_registerModelPostFixer GHS post-fixer} for more details.
+     * {@link module:html-support/datafilter~DataFilter#_registerCoupledAttributesPostFixer GHS post-fixer} for more details.
      */
     coupledAttribute?: string;
     /**

package/src/fullpage.d.ts

@@ -13,7 +13,7 @@ export default class FullPage extends Plugin {
     /**
      * @inheritDoc
      */
-    static get pluginName(): 'FullPage';
+    static get pluginName(): "FullPage";
     /**
      * @inheritDoc
      */

package/src/generalhtmlsupport.d.ts

@@ -29,7 +29,7 @@ export default class GeneralHtmlSupport extends Plugin {
     /**
      * @inheritDoc
      */
-    static get pluginName(): 'GeneralHtmlSupport';
+    static get pluginName(): "GeneralHtmlSupport";
     /**
      * @inheritDoc
      */

package/src/generalhtmlsupport.js

@@ -18,7 +18,7 @@ import TableElementSupport from './integrations/table';
 import StyleElementSupport from './integrations/style';
 import DocumentListElementSupport from './integrations/documentlist';
 import CustomElementSupport from './integrations/customelement';
-import { modifyGhsAttribute } from './utils';
+import { getHtmlAttributeName, modifyGhsAttribute } from './utils';
 /**
  * The General HTML Support feature.
  *
@@ -73,7 +73,7 @@ export default class GeneralHtmlSupport extends Plugin {
         if (inlineDefinition) {
             return inlineDefinition.model;
         }
-        return 'htmlAttributes';
+        return getHtmlAttributeName(viewElementName);
     }
     /**
      * Updates GHS model attribute for a specified view element name, so it includes the given class name.

package/src/htmlcomment.d.ts

@@ -16,7 +16,7 @@ export default class HtmlComment extends Plugin {
     /**
      * @inheritDoc
      */
-    static get pluginName(): 'HtmlComment';
+    static get pluginName(): "HtmlComment";
     /**
      * @inheritDoc
      */

package/src/htmlcomment.js

@@ -21,6 +21,7 @@ export default class HtmlComment extends Plugin {
      */
     init() {
         const editor = this.editor;
+        const loadedCommentsContent = new Map();
         editor.data.processor.skipComments = false;
         // Allow storing comment's content as the $root attribute with the name `$comment:<unique id>`.
         editor.model.schema.addAttributeCheck((context, attributeName) => {
@@ -32,11 +33,11 @@ export default class HtmlComment extends Plugin {
         // attribute. The comment content is needed in the `dataDowncast` pipeline to re-create the comment node.
         editor.conversion.for('upcast').elementToMarker({
             view: '$comment',
-            model: (viewElement, { writer }) => {
-                const root = this.editor.model.document.getRoot();
+            model: viewElement => {
+                const markerUid = uid();
+                const markerName = `$comment:${markerUid}`;
                 const commentContent = viewElement.getCustomProperty('$rawContent');
-                const markerName = `$comment:${uid()}`;
-                writer.setAttribute(markerName, commentContent, root);
+                loadedCommentsContent.set(markerName, commentContent);
                 return markerName;
             }
         });
@@ -44,7 +45,13 @@ export default class HtmlComment extends Plugin {
         editor.conversion.for('dataDowncast').markerToElement({
             model: '$comment',
             view: (modelElement, { writer }) => {
-                const root = this.editor.model.document.getRoot();
+                let root = undefined;
+                for (const rootName of this.editor.model.document.getRootNames()) {
+                    root = this.editor.model.document.getRoot(rootName);
+                    if (root.hasAttribute(modelElement.markerName)) {
+                        break;
+                    }
+                }
                 const markerName = modelElement.markerName;
                 const commentContent = root.getAttribute(markerName);
                 const comment = writer.createUIElement('$comment');
@@ -52,25 +59,45 @@ export default class HtmlComment extends Plugin {
                 return comment;
             }
         });
-        // Remove comments' markers and their corresponding $root attributes, which are no longer present.
+        // Remove comments' markers and their corresponding $root attributes, which are moved to the graveyard.
         editor.model.document.registerPostFixer(writer => {
-            const root = editor.model.document.getRoot();
-            const changedMarkers = editor.model.document.differ.getChangedMarkers();
-            const changedCommentMarkers = changedMarkers.filter(marker => {
-                return marker.name.startsWith('$comment');
-            });
-            const removedCommentMarkers = changedCommentMarkers.filter(marker => {
-                const newRange = marker.data.newRange;
-                return newRange && newRange.root.rootName === '$graveyard';
-            });
-            if (removedCommentMarkers.length === 0) {
-                return false;
-            }
-            for (const marker of removedCommentMarkers) {
-                writer.removeMarker(marker.name);
-                writer.removeAttribute(marker.name, root);
+            let changed = false;
+            const markers = editor.model.document.differ.getChangedMarkers().filter(marker => marker.name.startsWith('$comment:'));
+            for (const marker of markers) {
+                const { oldRange, newRange } = marker.data;
+                if (oldRange && newRange && oldRange.root == newRange.root) {
+                    // The marker was moved in the same root. Don't do anything.
+                    continue;
+                }
+                if (oldRange) {
+                    // The comment marker was moved from one root to another (most probably to the graveyard).
+                    // Remove the related attribute from the previous root.
+                    const oldRoot = oldRange.root;
+                    if (oldRoot.hasAttribute(marker.name)) {
+                        writer.removeAttribute(marker.name, oldRoot);
+                        changed = true;
+                    }
+                }
+                if (newRange) {
+                    const newRoot = newRange.root;
+                    if (newRoot.rootName == '$graveyard') {
+                        // Comment marker was moved to the graveyard -- remove it entirely.
+                        writer.removeMarker(marker.name);
+                        changed = true;
+                    }
+                    else if (!newRoot.hasAttribute(marker.name)) {
+                        // Comment marker was just added or was moved to another root - updated roots attributes.
+                        //
+                        // Added fallback to `''` for the comment content in case if someone incorrectly added just the marker "by hand"
+                        // and forgot to add the root attribute or add them in different change blocks.
+                        //
+                        // It caused an infinite loop in one of the unit tests.
+                        writer.setAttribute(marker.name, loadedCommentsContent.get(marker.name) || '', newRoot);
+                        changed = true;
+                    }
+                }
             }
-            return true;
+            return changed;
         });
         // Delete all comment markers from the document before setting new data.
         editor.data.on('set', () => {
@@ -109,7 +136,7 @@ export default class HtmlComment extends Plugin {
         const id = uid();
         const editor = this.editor;
         const model = editor.model;
-        const root = model.document.getRoot();
+        const root = model.document.getRoot(position.root.rootName);
         const markerName = `$comment:${id}`;
         return model.change(writer => {
             const range = writer.createRange(position);
@@ -135,14 +162,12 @@ export default class HtmlComment extends Plugin {
      */
     removeHtmlComment(commentID) {
         const editor = this.editor;
-        const root = editor.model.document.getRoot();
         const marker = editor.model.markers.get(commentID);
         if (!marker) {
             return false;
         }
         editor.model.change(writer => {
             writer.removeMarker(marker);
-            writer.removeAttribute(commentID, root);
         });
         return true;
     }
@@ -155,12 +180,19 @@ export default class HtmlComment extends Plugin {
     getHtmlCommentData(commentID) {
         const editor = this.editor;
         const marker = editor.model.markers.get(commentID);
-        const root = editor.model.document.getRoot();
         if (!marker) {
             return null;
         }
+        let content = '';
+        for (const rootName of this.editor.model.document.getRootNames()) {
+            const root = editor.model.document.getRoot(rootName);
+            if (root.hasAttribute(commentID)) {
+                content = root.getAttribute(commentID);
+                break;
+            }
+        }
         return {
-            content: root.getAttribute(commentID),
+            content,
             position: marker.getStart()
         };
     }

package/src/index.d.ts

@@ -7,7 +7,7 @@
  */
 export { default as GeneralHtmlSupport } from './generalhtmlsupport';
 export { default as DataFilter } from './datafilter';
-export { default as DataSchema } from './dataschema';
+export { default as DataSchema, type DataSchemaBlockElementDefinition } from './dataschema';
 export { default as HtmlComment } from './htmlcomment';
 export { default as FullPage } from './fullpage';
 export { default as HtmlPageDataProcessor } from './htmlpagedataprocessor';

package/src/integrations/codeblock.d.ts

@@ -15,7 +15,7 @@ export default class CodeBlockElementSupport extends Plugin {
     /**
      * @inheritDoc
      */
-    static get pluginName(): 'CodeBlockElementSupport';
+    static get pluginName(): "CodeBlockElementSupport";
     /**
      * @inheritDoc
      */

package/src/integrations/codeblock.js

@@ -38,7 +38,7 @@ export default class CodeBlockElementSupport extends Plugin {
             const conversion = editor.conversion;
             // Extend codeBlock to allow attributes required by attribute filtration.
             schema.extend('codeBlock', {
-                allowAttributes: ['htmlAttributes', 'htmlContentAttributes']
+                allowAttributes: ['htmlPreAttributes', 'htmlContentAttributes']
             });
             conversion.for('upcast').add(viewToModelCodeBlockAttributeConverter(dataFilter));
             conversion.for('downcast').add(modelToViewCodeBlockAttributeConverter());
@@ -50,7 +50,7 @@ export default class CodeBlockElementSupport extends Plugin {
  * View-to-model conversion helper preserving allowed attributes on {@link module:code-block/codeblock~CodeBlock Code Block}
  * feature model element.
  *
- * Attributes are preserved as a value of `htmlAttributes` model attribute.
+ * Attributes are preserved as a value of `html*Attributes` model attribute.
  * @param dataFilter
  * @returns Returns a conversion callback.
  */
@@ -62,7 +62,7 @@ function viewToModelCodeBlockAttributeConverter(dataFilter) {
             if (!viewPreElement || !viewPreElement.is('element', 'pre')) {
                 return;
             }
-            preserveElementAttributes(viewPreElement, 'htmlAttributes');
+            preserveElementAttributes(viewPreElement, 'htmlPreAttributes');
             preserveElementAttributes(viewCodeElement, 'htmlContentAttributes');
             function preserveElementAttributes(viewElement, attributeName) {
                 const viewAttributes = dataFilter.processViewAttributes(viewElement, conversionApi);
@@ -80,7 +80,7 @@ function viewToModelCodeBlockAttributeConverter(dataFilter) {
  */
 function modelToViewCodeBlockAttributeConverter() {
     return (dispatcher) => {
-        dispatcher.on('attribute:htmlAttributes:codeBlock', (evt, data, conversionApi) => {
+        dispatcher.on('attribute:htmlPreAttributes:codeBlock', (evt, data, conversionApi) => {
             if (!conversionApi.consumable.consume(data.item, evt.name)) {
                 return;
             }

package/src/integrations/customelement.d.ts

@@ -19,7 +19,7 @@ export default class CustomElementSupport extends Plugin {
     /**
      * @inheritDoc
      */
-    static get pluginName(): 'CustomElementSupport';
+    static get pluginName(): "CustomElementSupport";
     /**
      * @inheritDoc
      */

package/src/integrations/customelement.js

@@ -42,7 +42,7 @@ export default class CustomElementSupport extends Plugin {
             const preLikeElements = editor.data.htmlProcessor.domConverter.preElements;
             schema.register(definition.model, definition.modelSchema);
             schema.extend(definition.model, {
-                allowAttributes: ['htmlElementName', 'htmlAttributes', 'htmlContent'],
+                allowAttributes: ['htmlElementName', 'htmlCustomElementAttributes', 'htmlContent'],
                 isContent: true
             });
             // Being executed on the low priority, it will catch all elements that were not caught by other converters.
@@ -74,7 +74,7 @@ export default class CustomElementSupport extends Plugin {
                     });
                     const htmlAttributes = dataFilter.processViewAttributes(viewElement, conversionApi);
                     if (htmlAttributes) {
-                        conversionApi.writer.setAttribute('htmlAttributes', htmlAttributes, modelElement);
+                        conversionApi.writer.setAttribute('htmlCustomElementAttributes', 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);
@@ -94,13 +94,13 @@ export default class CustomElementSupport extends Plugin {
             conversion.for('editingDowncast').elementToElement({
                 model: {
                     name: definition.model,
-                    attributes: ['htmlElementName', 'htmlAttributes', 'htmlContent']
+                    attributes: ['htmlElementName', 'htmlCustomElementAttributes', 'htmlContent']
                 },
                 view: (modelElement, { writer }) => {
                     const viewName = modelElement.getAttribute('htmlElementName');
                     const viewElement = writer.createRawElement(viewName);
-                    if (modelElement.hasAttribute('htmlAttributes')) {
-                        setViewAttributes(writer, modelElement.getAttribute('htmlAttributes'), viewElement);
+                    if (modelElement.hasAttribute('htmlCustomElementAttributes')) {
+                        setViewAttributes(writer, modelElement.getAttribute('htmlCustomElementAttributes'), viewElement);
                     }
                     return viewElement;
                 }
@@ -108,7 +108,7 @@ export default class CustomElementSupport extends Plugin {
             conversion.for('dataDowncast').elementToElement({
                 model: {
                     name: definition.model,
-                    attributes: ['htmlElementName', 'htmlAttributes', 'htmlContent']
+                    attributes: ['htmlElementName', 'htmlCustomElementAttributes', 'htmlContent']
                 },
                 view: (modelElement, { writer }) => {
                     const viewName = modelElement.getAttribute('htmlElementName');
@@ -123,8 +123,8 @@ export default class CustomElementSupport extends Plugin {
                             domElement.appendChild(customElement.firstChild);
                         }
                     });
-                    if (modelElement.hasAttribute('htmlAttributes')) {
-                        setViewAttributes(writer, modelElement.getAttribute('htmlAttributes'), viewElement);
+                    if (modelElement.hasAttribute('htmlCustomElementAttributes')) {
+                        setViewAttributes(writer, modelElement.getAttribute('htmlCustomElementAttributes'), viewElement);
                     }
                     return viewElement;
                 }

package/src/integrations/documentlist.d.ts

@@ -15,7 +15,7 @@ export default class DocumentListElementSupport extends Plugin {
     /**
      * @inheritDoc
      */
-    static get pluginName(): 'DocumentListElementSupport';
+    static get pluginName(): "DocumentListElementSupport";
     /**
      * @inheritDoc
      */

package/src/integrations/documentlist.js

@@ -7,7 +7,7 @@
  */
 import { isEqual } from 'lodash-es';
 import { Plugin } from 'ckeditor5/src/core';
-import { setViewAttributes } from '../utils';
+import { getHtmlAttributeName, setViewAttributes } from '../utils';
 import DataFilter from '../datafilter';
 /**
  * Provides the General HTML Support integration with the {@link module:list/documentlist~DocumentList Document List} feature.
@@ -37,37 +37,40 @@ export default class DocumentListElementSupport extends Plugin {
         const conversion = editor.conversion;
         const dataFilter = editor.plugins.get(DataFilter);
         const documentListEditing = editor.plugins.get('DocumentListEditing');
+        const viewElements = ['ul', 'ol', 'li'];
         // Register downcast strategy.
         // Note that this must be done before document list editing registers conversion in afterInit.
         documentListEditing.registerDowncastStrategy({
             scope: 'item',
             attributeName: 'htmlLiAttributes',
-            setAttributeOnDowncast(writer, attributeValue, viewElement) {
-                setViewAttributes(writer, attributeValue, viewElement);
-            }
+            setAttributeOnDowncast: setViewAttributes
         });
         documentListEditing.registerDowncastStrategy({
             scope: 'list',
-            attributeName: 'htmlListAttributes',
-            setAttributeOnDowncast(writer, viewAttributes, viewElement) {
-                setViewAttributes(writer, viewAttributes, viewElement);
-            }
+            attributeName: 'htmlUlAttributes',
+            setAttributeOnDowncast: setViewAttributes
+        });
+        documentListEditing.registerDowncastStrategy({
+            scope: 'list',
+            attributeName: 'htmlOlAttributes',
+            setAttributeOnDowncast: setViewAttributes
         });
         dataFilter.on('register', (evt, definition) => {
-            if (!['ul', 'ol', 'li'].includes(definition.view)) {
+            if (!viewElements.includes(definition.view)) {
                 return;
             }
             evt.stop();
             // Do not register same converters twice.
-            if (schema.checkAttribute('$block', 'htmlListAttributes')) {
+            if (schema.checkAttribute('$block', 'htmlLiAttributes')) {
                 return;
             }
-            schema.extend('$block', { allowAttributes: ['htmlListAttributes', 'htmlLiAttributes'] });
-            schema.extend('$blockObject', { allowAttributes: ['htmlListAttributes', 'htmlLiAttributes'] });
-            schema.extend('$container', { allowAttributes: ['htmlListAttributes', 'htmlLiAttributes'] });
+            const allowAttributes = viewElements.map(element => getHtmlAttributeName(element));
+            schema.extend('$block', { allowAttributes });
+            schema.extend('$blockObject', { allowAttributes });
+            schema.extend('$container', { allowAttributes });
             conversion.for('upcast').add(dispatcher => {
-                dispatcher.on('element:ul', viewToModelListAttributeConverter('htmlListAttributes', dataFilter), { priority: 'low' });
-                dispatcher.on('element:ol', viewToModelListAttributeConverter('htmlListAttributes', dataFilter), { priority: 'low' });
+                dispatcher.on('element:ul', viewToModelListAttributeConverter('htmlUlAttributes', dataFilter), { priority: 'low' });
+                dispatcher.on('element:ol', viewToModelListAttributeConverter('htmlOlAttributes', dataFilter), { priority: 'low' });
                 dispatcher.on('element:li', viewToModelListAttributeConverter('htmlLiAttributes', dataFilter), { priority: 'low' });
             });
         });
@@ -102,21 +105,38 @@ export default class DocumentListElementSupport extends Plugin {
                     continue;
                 }
                 if (previousNodeInList.getAttribute('listType') == node.getAttribute('listType')) {
-                    const value = previousNodeInList.getAttribute('htmlListAttributes');
-                    if (!isEqual(node.getAttribute('htmlListAttributes'), value)) {
-                        writer.setAttribute('htmlListAttributes', value, node);
+                    const attribute = getAttributeFromListType(previousNodeInList.getAttribute('listType'));
+                    const value = previousNodeInList.getAttribute(attribute);
+                    if (!isEqual(node.getAttribute(attribute), value) &&
+                        writer.model.schema.checkAttribute(node, attribute)) {
+                        writer.setAttribute(attribute, value, node);
                         evt.return = true;
                     }
                 }
                 if (previousNodeInList.getAttribute('listItemId') == node.getAttribute('listItemId')) {
                     const value = previousNodeInList.getAttribute('htmlLiAttributes');
-                    if (!isEqual(node.getAttribute('htmlLiAttributes'), value)) {
+                    if (!isEqual(node.getAttribute('htmlLiAttributes'), value) &&
+                        writer.model.schema.checkAttribute(node, 'htmlLiAttributes')) {
                         writer.setAttribute('htmlLiAttributes', value, node);
                         evt.return = true;
                     }
                 }
             }
         });
+        // Remove `ol` attributes from `ul` elements and vice versa.
+        documentListEditing.on('postFixer', (evt, { listNodes, writer }) => {
+            for (const { node } of listNodes) {
+                const listType = node.getAttribute('listType');
+                if (listType === 'bulleted' && node.getAttribute('htmlOlAttributes')) {
+                    writer.removeAttribute('htmlOlAttributes', node);
+                    evt.return = true;
+                }
+                if (listType === 'numbered' && node.getAttribute('htmlUlAttributes')) {
+                    writer.removeAttribute('htmlUlAttributes', node);
+                    evt.return = true;
+                }
+            }
+        });
     }
     /**
      * @inheritDoc
@@ -131,10 +151,14 @@ export default class DocumentListElementSupport extends Plugin {
         this.listenTo(indentList, 'afterExecute', (evt, changedBlocks) => {
             editor.model.change(writer => {
                 for (const node of changedBlocks) {
+                    const attribute = getAttributeFromListType(node.getAttribute('listType'));
+                    if (!editor.model.schema.checkAttribute(node, attribute)) {
+                        continue;
+                    }
                     // Just reset the attribute.
                     // If there is a previous indented list that this node should be merged into,
                     // the postfixer will unify all the attributes of both sub-lists.
-                    writer.setAttribute('htmlListAttributes', {}, node);
+                    writer.setAttribute(attribute, {}, node);
                 }
             });
         });
@@ -147,7 +171,7 @@ export default class DocumentListElementSupport extends Plugin {
  * @returns Returns a conversion callback.
  */
 function viewToModelListAttributeConverter(attributeName, dataFilter) {
-    const callback = (evt, data, conversionApi) => {
+    return (evt, data, conversionApi) => {
         const viewElement = data.viewItem;
         if (!data.modelRange) {
             Object.assign(data, conversionApi.convertChildren(data.viewItem, data.modelCursor));
@@ -163,8 +187,17 @@ function viewToModelListAttributeConverter(attributeName, dataFilter) {
             if (item.hasAttribute(attributeName)) {
                 continue;
             }
-            conversionApi.writer.setAttribute(attributeName, viewAttributes || {}, item);
+            if (conversionApi.writer.model.schema.checkAttribute(item, attributeName)) {
+                conversionApi.writer.setAttribute(attributeName, viewAttributes || {}, item);
+            }
         }
     };
-    return callback;
+}
+/**
+ * Returns HTML attribute name based on provided list type.
+ */
+function getAttributeFromListType(listType) {
+    return listType === 'bulleted' ?
+        'htmlUlAttributes' :
+        'htmlOlAttributes';
 }