CKE-77 issue in rich text sanitizer attributes loop

packages/ckeditor5-coremedia-content-clipboard/src/DataToModelMechanism.ts

@@ -237,7 +237,14 @@ export default class DataToModelMechanism {
         insertPosition = writer.split(markerPosition).range.end;
       }
       const range = writer.model.insertContent(item, insertPosition);
-      DataToModelMechanism.#applyAttributes(writer, [range], contentInputData.insertionContext.selectedAttributes);
+      if (range.start.path.length === 2 && range.end.path.length === 2) {
+        // applying attributes for empty rows leads to a bad element structure (e.g. strong tag surrounding a paragraph) (CKE-75)
+        // avoid applying the linkHref attribute of the link which ended right before this one (CKE-69)
+        const filteredAttributes = contentInputData.insertionContext.selectedAttributes.filter(
+          (arr) => arr[0] !== "linkHref",
+        );
+        DataToModelMechanism.#applyAttributes(writer, [range], filteredAttributes);
+      }
 
       // Evaluate if the container element has to be split after the element has
       // been inserted.

packages/ckeditor5-coremedia-richtext/__tests__/sanitation/RichTextSanitizer.test.ts

@@ -154,10 +154,19 @@ describe("RichTextSanitizer", () => {
 
           it("Should remove invalid attributes", () => {
             const validXml = richtext(p());
-            const invalidXml = richtext(p("", { class: "I" })).replace("class", "invalid");
+            const invalidXml = richtext(
+              p("", {
+                class: "I",
+                lang: "A",
+                dir: "ltr",
+              }),
+            )
+              .replace("class", "invalid1")
+              .replace("lang", "invalid2")
+              .replace("dir", "invalid3");
             expectSanitationResult(sanitizer, invalidXml, validXml, (listener) => {
-              expect(listener.totalLength).toStrictEqual(1);
-              expect(listener.removedInvalidAttrs).toHaveLength(1);
+              expect(listener.totalLength).toStrictEqual(3);
+              expect(listener.removedInvalidAttrs).toHaveLength(3);
             });
           });
 

packages/ckeditor5-coremedia-richtext/src/sanitation/ElementConfig.ts

@@ -3,10 +3,10 @@ import { allowEmpty, ElementContent, pcdata } from "./ElementContent";
 import { ActiveStrictness } from "../Strictness";
 import { SanitationListener } from "./SanitationListener";
 import {
-  isText,
   isElement,
-  isParentNode,
   isHasNamespaceUri,
+  isParentNode,
+  isText,
   lookupNamespaceURI,
 } from "@coremedia/ckeditor5-dom-support";
 import { isKnownNamespacePrefix, namespaces } from "../Namespaces";
@@ -287,43 +287,35 @@ export class ElementConfig {
    */
   #processAttributes(element: Element, strictness: ActiveStrictness, listener: SanitationListener): void {
     const { attributes } = element;
+    const attributesToRemoveFromElement: Attr[] = [];
+    const attributesToRemoveFromListener: Attr[] = [];
     for (const attribute of attributes) {
       if (attribute.localName === "xmlns" || attribute.prefix === "xmlns" || attribute.localName.startsWith("xmlns:")) {
         // Namespaces handled later.
         continue;
       }
-      this.#processAttributeOf(element, attribute, listener, strictness);
-    }
-    this.#processRequiredAttributes(element);
-  }
+      const config = this.#getAttributeConfig(attribute);
 
-  #processAttributeOf(
-    element: Element,
-    attribute: Attr,
-    listener: SanitationListener,
-    strictness: ActiveStrictness,
-  ): void {
-    const config = this.#getAttributeConfig(attribute);
-
-    if (!config) {
-      listener.removeInvalidAttr(element, attribute, "invalidAtElement");
-      element.removeAttributeNode(attribute);
-    } else {
-      const { fixed } = config;
-      const { value } = attribute;
-      // Cleanup: Remove fixed attributes, that are irrelevant to store.
-      if (fixed && fixed === value) {
-        // Cleanup: We expect a fixed value to be valid by definition and that
-        // it is obsolete to forward it to stored data.
-        element.removeAttributeNode(attribute);
-      } else if (!config.validateValue(value, strictness)) {
-        listener.removeInvalidAttr(element, attribute, "invalidValue");
-        element.removeAttributeNode(attribute);
+      if (!config) {
+        attributesToRemoveFromListener.push(attribute);
+        attributesToRemoveFromElement.push(attribute);
+      } else {
+        const { fixed } = config;
+        const { value } = attribute;
+        // Cleanup: Remove fixed attributes, that are irrelevant to store.
+        if (fixed && fixed === value) {
+          // Cleanup: We expect a fixed value to be valid by definition and that
+          // it is obsolete to forward it to stored data.
+          attributesToRemoveFromElement.push(attribute);
+        } else if (!config.validateValue(value, strictness)) {
+          attributesToRemoveFromListener.push(attribute);
+          attributesToRemoveFromElement.push(attribute);
+        }
       }
-
-      // We may, as suggested by TSDoc, also remove irrelevant attributes if
-      // they match the default values as provided by DTD. Skipped for now.
     }
+    attributesToRemoveFromListener.forEach((attr) => listener.removeInvalidAttr(element, attr, "invalidAtElement"));
+    attributesToRemoveFromElement.forEach((attr) => element.removeAttributeNode(attr));
+    this.#processRequiredAttributes(element);
   }
 
   /**