@ckeditor/ckeditor5-clipboard 0.0.0-nightly-next-20260111.0 → 0.0.0-nightly-20260112.0

package/src/pasteplaintext.js

@@ -0,0 +1,102 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module clipboard/pasteplaintext
+ */
+import { Plugin } from '@ckeditor/ckeditor5-core';
+import { ClipboardObserver } from './clipboardobserver.js';
+import { ClipboardPipeline } from './clipboardpipeline.js';
+/**
+ * The plugin detects the user's intention to paste plain text.
+ *
+ * For example, it detects the <kbd>Ctrl/Cmd</kbd> + <kbd>Shift</kbd> + <kbd>V</kbd> keystroke.
+ */
+export class PastePlainText extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'PastePlainText';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [ClipboardPipeline];
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        const model = editor.model;
+        const view = editor.editing.view;
+        const selection = model.document.selection;
+        view.addObserver(ClipboardObserver);
+        editor.plugins.get(ClipboardPipeline).on('contentInsertion', (evt, data) => {
+            if (!isUnformattedInlineContent(data.content, model)) {
+                return;
+            }
+            model.change(writer => {
+                // Formatting attributes should be preserved.
+                const textAttributes = Array.from(selection.getAttributes())
+                    .filter(([key]) => model.schema.getAttributeProperties(key).isFormatting);
+                if (!selection.isCollapsed) {
+                    model.deleteContent(selection, { doNotAutoparagraph: true });
+                }
+                // Also preserve other attributes if they survived the content deletion (because they were not fully selected).
+                // For example linkHref is not a formatting attribute but it should be preserved if pasted text was in the middle
+                // of a link.
+                textAttributes.push(...selection.getAttributes());
+                const range = writer.createRangeIn(data.content);
+                for (const item of range.getItems()) {
+                    for (const attribute of textAttributes) {
+                        if (model.schema.checkAttribute(item, attribute[0])) {
+                            writer.setAttribute(attribute[0], attribute[1], item);
+                        }
+                    }
+                }
+            });
+        });
+    }
+}
+/**
+ * Returns true if specified `documentFragment` represents the unformatted inline content.
+ */
+function isUnformattedInlineContent(documentFragment, model) {
+    let range = model.createRangeIn(documentFragment);
+    // We consider three scenarios here. The document fragment may include:
+    //
+    // 1. Only text and inline objects. Then it could be unformatted inline content.
+    // 2. Exactly one block element on top-level, eg. <p>Foobar</p> or <h2>Title</h2>.
+    //    In this case, check this element content, it could be treated as unformatted inline content.
+    // 3. More block elements or block objects, then it is not unformatted inline content.
+    //
+    // We will check for scenario 2. specifically, and if it happens, we will unwrap it and follow with the regular algorithm.
+    //
+    if (documentFragment.childCount == 1) {
+        const child = documentFragment.getChild(0);
+        if (child.is('element') && model.schema.isBlock(child) && !model.schema.isObject(child) && !model.schema.isLimit(child)) {
+            // Scenario 2. as described above.
+            range = model.createRangeIn(child);
+        }
+    }
+    for (const child of range.getItems()) {
+        if (!model.schema.isInline(child)) {
+            return false;
+        }
+        const attributeKeys = Array.from(child.getAttributeKeys());
+        if (attributeKeys.find(key => model.schema.getAttributeProperties(key).isFormatting)) {
+            return false;
+        }
+    }
+    return true;
+}

package/{dist → src}/utils/normalizeclipboarddata.d.ts

@@ -1,7 +1,3 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
 /**
  * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options

package/src/utils/normalizeclipboarddata.js

@@ -0,0 +1,28 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module clipboard/utils/normalizeclipboarddata
+ */
+/**
+ * Removes some popular browser quirks out of the clipboard data (HTML).
+ * Removes all HTML comments. These are considered an internal thing and it makes little sense if they leak into the editor data.
+ *
+ * @param data The HTML data to normalize.
+ * @returns Normalized HTML.
+ * @internal
+ */
+export function normalizeClipboardData(data) {
+    return data
+        .replace(/<span(?: class="Apple-converted-space"|)>(\s+)<\/span>/g, (fullMatch, spaces) => {
+        // Handle the most popular and problematic case when even a single space becomes an nbsp;.
+        // Decode those to normal spaces. Read more in https://github.com/ckeditor/ckeditor5-clipboard/issues/2.
+        if (spaces.length == 1) {
+            return ' ';
+        }
+        return spaces;
+    })
+        // Remove all HTML comments.
+        .replace(/<!--[\s\S]*?-->/g, '');
+}

package/{dist → src}/utils/plaintexttohtml.d.ts

@@ -1,7 +1,3 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
 /**
  * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options

package/src/utils/plaintexttohtml.js

@@ -0,0 +1,39 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module clipboard/utils/plaintexttohtml
+ */
+/**
+ * Converts plain text to its HTML-ized version.
+ *
+ * @param text The plain text to convert.
+ * @returns HTML generated from the plain text.
+ */
+export function plainTextToHtml(text) {
+    text = text
+        // Encode &.
+        .replace(/&/g, '&')
+        // Encode <>.
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        // Creates a paragraph for each double line break.
+        .replace(/\r?\n\r?\n/g, '</p><p>')
+        // Creates a line break for each single line break.
+        .replace(/\r?\n/g, '<br>')
+        // Replace tabs with four spaces.
+        .replace(/\t/g, '&nbsp;&nbsp;&nbsp;&nbsp;')
+        // Preserve trailing spaces (only the first and last one – the rest is handled below).
+        .replace(/^\s/, '&nbsp;')
+        .replace(/\s$/, '&nbsp;')
+        // Preserve other subsequent spaces now.
+        .replace(/\s\s/g, ' &nbsp;');
+    if (text.includes('</p><p>') || text.includes('<br>')) {
+        // If we created paragraphs above, add the trailing ones.
+        text = `<p>${text}</p>`;
+    }
+    // TODO:
+    // * What about '\nfoo' vs ' foo'?
+    return text;
+}

package/{dist → src}/utils/viewtoplaintext.d.ts

@@ -1,7 +1,3 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
 /**
  * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options

package/src/utils/viewtoplaintext.js

@@ -0,0 +1,96 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+// Elements which should not have empty-line padding.
+// Most `view.ContainerElement` want to be separate by new-line, but some are creating one structure
+// together (like `<li>`) so it is better to separate them by only one "\n".
+const smallPaddingElements = ['figcaption', 'li'];
+const listElements = ['ol', 'ul'];
+/**
+ * Converts {@link module:engine/view/item~ViewItem view item} and all of its children to plain text.
+ *
+ * @param converter The converter instance.
+ * @param viewItem View item to convert.
+ * @returns Plain text representation of `viewItem`.
+ */
+export function viewToPlainText(converter, viewItem) {
+    if (viewItem.is('$text') || viewItem.is('$textProxy')) {
+        return viewItem.data;
+    }
+    if (viewItem.is('element', 'img') && viewItem.hasAttribute('alt')) {
+        return viewItem.getAttribute('alt');
+    }
+    if (viewItem.is('element', 'br')) {
+        return '\n'; // Convert soft breaks to single line break (#8045).
+    }
+    /**
+     * Item is a document fragment, attribute element or container element. It doesn't
+     * have it's own text value, so we need to convert its children elements.
+     */
+    let text = '';
+    let prev = null;
+    for (const child of viewItem.getChildren()) {
+        text += newLinePadding(child, prev) + viewToPlainText(converter, child);
+        prev = child;
+    }
+    // If item is a raw element, the only way to get its content is to render it and read the text directly from DOM.
+    if (viewItem.is('rawElement')) {
+        const doc = document.implementation.createHTMLDocument('');
+        const tempElement = doc.createElement('div');
+        viewItem.render(tempElement, converter);
+        text += domElementToPlainText(tempElement);
+    }
+    return text;
+}
+/**
+ * Recursively converts DOM element and all of its children to plain text.
+ */
+function domElementToPlainText(element) {
+    let text = '';
+    if (element.nodeType === Node.TEXT_NODE) {
+        return element.textContent;
+    }
+    else if (element.tagName === 'BR') {
+        return '\n';
+    }
+    for (const child of element.childNodes) {
+        text += domElementToPlainText(child);
+    }
+    return text;
+}
+/**
+ * Returns new line padding to prefix the given elements with.
+ */
+function newLinePadding(element, previous) {
+    if (!previous) {
+        // Don't add padding to first elements in a level.
+        return '';
+    }
+    if (element.is('element', 'li') && !element.isEmpty && element.getChild(0).is('containerElement')) {
+        // Separate document list items with empty lines.
+        return '\n\n';
+    }
+    if (listElements.includes(element.name) && listElements.includes(previous.name)) {
+        /**
+         * Because `<ul>` and `<ol>` are ViewAttributeElements, two consecutive lists will not have any padding between
+         * them (see the `if` statement below). To fix this, we need to make an exception for this case.
+         */
+        return '\n\n';
+    }
+    if (!element.is('containerElement') && !previous.is('containerElement')) {
+        // Don't add padding between non-container elements.
+        return '';
+    }
+    if (smallPaddingElements.includes(element.name) || smallPaddingElements.includes(previous.name)) {
+        // Add small padding between selected container elements.
+        return '\n';
+    }
+    // Do not add padding around the elements that won't be rendered.
+    if (element.is('element') && element.getCustomProperty('dataPipeline:transparentRendering') ||
+        previous.is('element') && previous.getCustomProperty('dataPipeline:transparentRendering')) {
+        return '';
+    }
+    // Add empty lines between container elements.
+    return '\n\n';
+}