@ckeditor/ckeditor5-list 40.1.0 → 41.0.0

package/src/list/listcommand.d.ts

@@ -1,8 +1,12 @@
 /**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-import { Command, type Editor } from 'ckeditor5/src/core';
+/**
+ * @module list/list/listcommand
+ */
+import type { Element } from 'ckeditor5/src/engine.js';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
 /**
  * The list command. It is used by the {@link module:list/list~List list feature}.
  */
@@ -14,6 +18,7 @@ export default class ListCommand extends Command {
     /**
      * A flag indicating whether the command is active, which means that the selection starts in a list of the same type.
      *
+     * @observable
      * @readonly
      */
     value: boolean;
@@ -32,14 +37,21 @@ export default class ListCommand extends Command {
      * Executes the list command.
      *
      * @fires execute
+     * @fires afterExecute
      * @param options Command options.
      * @param options.forceValue If set, it will force the command behavior. If `true`, the command will try to convert the
-     * selected items and potentially the neighbor elements to the proper list items. If set to `false`, it will convert selected elements
+     * selected items and potentially the neighbor elements to the proper list items. If set to `false` it will convert selected elements
      * to paragraphs. If not set, the command will toggle selected elements to list items or paragraphs, depending on the selection.
      */
     execute(options?: {
         forceValue?: boolean;
     }): void;
+    /**
+     * Fires the `afterExecute` event.
+     *
+     * @param changedBlocks The changed list elements.
+     */
+    private _fireAfterExecute;
     /**
      * Checks the command's {@link #value}.
      *
@@ -53,3 +65,16 @@ export default class ListCommand extends Command {
      */
     private _checkEnabled;
 }
+/**
+ * Event fired by the {@link ~ListCommand#execute} method.
+ *
+ * It allows to execute an action after executing the {@link ~ListCommand#execute} method,
+ * for example adjusting attributes of changed list items.
+ *
+ * @internal
+ * @eventName ~ListCommand#afterExecute
+ */
+export type ListCommandAfterExecuteEvent = {
+    name: 'afterExecute';
+    args: [changedBlocks: Array<Element>];
+};

package/src/list/listcommand.js

@@ -1,9 +1,9 @@
 /**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-import { Command } from 'ckeditor5/src/core';
-import { first } from 'ckeditor5/src/utils';
+import { Command } from 'ckeditor5/src/core.js';
+import { splitListItemBefore, expandListBlocksToCompleteItems, getListItemBlocks, getListItems, removeListAttributes, outdentFollowingItems, ListItemUid, sortBlocks, getSelectedBlockObject, isListItemBlock, canBecomeSimpleListItem } from './utils/model.js';
 /**
  * The list command. It is used by the {@link module:list/list~List list feature}.
  */
@@ -29,175 +29,99 @@ export default class ListCommand extends Command {
      * Executes the list command.
      *
      * @fires execute
+     * @fires afterExecute
      * @param options Command options.
      * @param options.forceValue If set, it will force the command behavior. If `true`, the command will try to convert the
-     * selected items and potentially the neighbor elements to the proper list items. If set to `false`, it will convert selected elements
+     * selected items and potentially the neighbor elements to the proper list items. If set to `false` it will convert selected elements
      * to paragraphs. If not set, the command will toggle selected elements to list items or paragraphs, depending on the selection.
      */
     execute(options = {}) {
         const model = this.editor.model;
         const document = model.document;
+        const selectedBlockObject = getSelectedBlockObject(model);
         const blocks = Array.from(document.selection.getSelectedBlocks())
-            .filter(block => checkCanBecomeListItem(block, model.schema));
+            .filter(block => model.schema.checkAttribute(block, 'listType') || canBecomeSimpleListItem(block, model.schema));
         // Whether we are turning off some items.
         const turnOff = options.forceValue !== undefined ? !options.forceValue : this.value;
-        // If we are turning off items, we are going to rename them to paragraphs.
         model.change(writer => {
-            // If part of a list got turned off, we need to handle (outdent) all of sub-items of the last turned-off item.
-            // To be sure that model is all the time in a good state, we first fix items below turned-off item.
             if (turnOff) {
-                // Start from the model item that is just after the last turned-off item.
-                let next = blocks[blocks.length - 1].nextSibling;
-                let currentIndent = Number.POSITIVE_INFINITY;
-                let changes = [];
-                // Correct indent of all items after the last turned off item.
-                // Rules that should be followed:
-                // 1. All direct sub-items of turned-off item should become indent 0, because the first item after it
-                //    will be the first item of a new list. Other items are at the same level, so should have same 0 index.
-                // 2. All items with indent lower than indent of turned-off item should become indent 0, because they
-                //    should not end up as a child of any of list items that they were not children of before.
-                // 3. All other items should have their indent changed relatively to it's parent.
-                //
-                // For example:
-                // 1  * --------
-                // 2     * --------
-                // 3        * --------			<-- this is turned off.
-                // 4           * --------		<-- this has to become indent = 0, because it will be first item on a new list.
-                // 5              * --------	<-- this should be still be a child of item above, so indent = 1.
-                // 6        * --------			<-- this has to become indent = 0, because it should not be a child of any of items above.
-                // 7           * --------		<-- this should be still be a child of item above, so indent = 1.
-                // 8     * --------				<-- this has to become indent = 0.
-                // 9        * --------			<-- this should still be a child of item above, so indent = 1.
-                // 10          * --------		<-- this should still be a child of item above, so indent = 2.
-                // 11          * --------		<-- this should still be at the same level as item above, so indent = 2.
-                // 12 * --------				<-- this and all below are left unchanged.
-                // 13    * --------
-                // 14       * --------
-                //
-                // After turning off 3 the list becomes:
-                //
-                // 1  * --------
-                // 2     * --------
-                //
-                // 3  --------
-                //
-                // 4  * --------
-                // 5     * --------
-                // 6  * --------
-                // 7     * --------
-                // 8  * --------
-                // 9     * --------
-                // 10       * --------
-                // 11       * --------
-                // 12 * --------
-                // 13    * --------
-                // 14       * --------
-                //
-                // Thanks to this algorithm no lists are mismatched and no items get unexpected children/parent, while
-                // those parent-child connection which are possible to maintain are still maintained. It's worth noting
-                // that this is the same effect that we would be get by multiple use of outdent command. However doing
-                // it like this is much more efficient because it's less operation (less memory usage, easier OT) and
-                // less conversion (faster).
-                while (next && next.name == 'listItem' && next.getAttribute('listIndent') !== 0) {
-                    // Check each next list item, as long as its indent is bigger than 0.
-                    // If the indent is 0 we are not going to change anything anyway.
-                    const indent = next.getAttribute('listIndent');
-                    // We check if that's item indent is lower as current relative indent.
-                    if (indent < currentIndent) {
-                        // If it is, current relative indent becomes that indent.
-                        currentIndent = indent;
-                    }
-                    // Fix indent relatively to current relative indent.
-                    // Note, that if we just changed the current relative indent, the newIndent will be equal to 0.
-                    const newIndent = indent - currentIndent;
-                    // Save the entry in changes array. We do not apply it at the moment, because we will need to
-                    // reverse the changes so the last item is changed first.
-                    // This is to keep model in correct state all the time.
-                    changes.push({ element: next, listIndent: newIndent });
-                    // Find next item.
-                    next = next.nextSibling;
-                }
-                changes = changes.reverse();
-                for (const item of changes) {
-                    writer.setAttribute('listIndent', item.listIndent, item.element);
+                const lastBlock = blocks[blocks.length - 1];
+                // Split the first block from the list item.
+                const itemBlocks = getListItemBlocks(lastBlock, { direction: 'forward' });
+                const changedBlocks = [];
+                if (itemBlocks.length > 1) {
+                    changedBlocks.push(...splitListItemBefore(itemBlocks[1], writer));
                 }
+                // Strip list attributes.
+                changedBlocks.push(...removeListAttributes(blocks, writer));
+                // Outdent items following the selected list item.
+                changedBlocks.push(...outdentFollowingItems(lastBlock, writer));
+                this._fireAfterExecute(changedBlocks);
             }
-            // If we are turning on, we might change some items that are already `listItem`s but with different type.
-            // Changing one nested list item to other type should also trigger changing all its siblings so the
-            // whole nested list is of the same type.
-            // Example (assume changing to numbered list):
-            // * ------				<-- do not fix, top level item
-            //   * ------			<-- fix, because latter list item of this item's list is changed
-            //      * ------		<-- do not fix, item is not affected (different list)
-            //   * ------			<-- fix, because latter list item of this item's list is changed
-            //      * ------		<-- fix, because latter list item of this item's list is changed
-            //      * ---[--		<-- already in selection
-            //   * ------			<-- already in selection
-            //   * ------			<-- already in selection
-            // * ------				<-- already in selection, but does not cause other list items to change because is top-level
-            //   * ---]--			<-- already in selection
-            //   * ------			<-- fix, because preceding list item of this item's list is changed
-            //      * ------		<-- do not fix, item is not affected (different list)
-            // * ------				<-- do not fix, top level item
-            if (!turnOff) {
-                // Find lowest indent among selected items. This will be indicator what is the indent of
-                // top-most list affected by the command.
-                let lowestIndent = Number.POSITIVE_INFINITY;
-                for (const item of blocks) {
-                    if (item.is('element', 'listItem') && item.getAttribute('listIndent') < lowestIndent) {
-                        lowestIndent = item.getAttribute('listIndent');
-                    }
+            // Changing type of list items for a collapsed selection inside a list item.
+            else if ((selectedBlockObject || document.selection.isCollapsed) && isListItemBlock(blocks[0])) {
+                const changedBlocks = getListItems(selectedBlockObject || blocks[0]);
+                for (const block of changedBlocks) {
+                    writer.setAttribute('listType', this.type, block);
                 }
-                // Do not execute the fix for top-level lists.
-                lowestIndent = lowestIndent === 0 ? 1 : lowestIndent;
-                // Fix types of list items that are "before" the selected blocks.
-                _fixType(blocks, true, lowestIndent);
-                // Fix types of list items that are "after" the selected blocks.
-                _fixType(blocks, false, lowestIndent);
+                this._fireAfterExecute(changedBlocks);
             }
-            // Phew! Now it will be easier :).
-            // For each block element that was in the selection, we will either: turn it to list item,
-            // turn it to paragraph, or change it's type. Or leave it as it is.
-            // Do it in reverse as there might be multiple blocks (same as with changing indents).
-            for (const element of blocks.reverse()) {
-                if (turnOff && element.name == 'listItem') {
-                    // We are turning off and the element is a `listItem` - it should be converted to `paragraph`.
-                    // List item specific attributes are removed by post fixer.
-                    writer.rename(element, 'paragraph');
-                }
-                else if (!turnOff && element.name != 'listItem') {
-                    // We are turning on and the element is not a `listItem` - it should be converted to `listItem`.
-                    // The order of operations is important to keep model in correct state.
-                    writer.setAttributes({ listType: this.type, listIndent: 0 }, element);
-                    writer.rename(element, 'listItem');
-                }
-                else if (!turnOff && element.name == 'listItem' && element.getAttribute('listType') != this.type) {
-                    // We are turning on and the element is a `listItem` but has different type - change it's type and
-                    // type of it's all siblings that have same indent.
-                    writer.setAttribute('listType', this.type, element);
+            // Turning on the list items for a non-collapsed selection.
+            else {
+                const changedBlocks = [];
+                for (const block of blocks) {
+                    // Promote the given block to the list item.
+                    if (!block.hasAttribute('listType')) {
+                        // Rename block to a simple list item if this option is enabled.
+                        if (!block.is('element', 'listItem') && canBecomeSimpleListItem(block, model.schema)) {
+                            writer.rename(block, 'listItem');
+                        }
+                        writer.setAttributes({
+                            listIndent: 0,
+                            listItemId: ListItemUid.next(),
+                            listType: this.type
+                        }, block);
+                        changedBlocks.push(block);
+                    }
+                    // Change the type of list item.
+                    else {
+                        for (const node of expandListBlocksToCompleteItems(block, { withNested: false })) {
+                            if (node.getAttribute('listType') != this.type) {
+                                writer.setAttribute('listType', this.type, node);
+                                changedBlocks.push(node);
+                            }
+                        }
+                    }
                 }
+                this._fireAfterExecute(changedBlocks);
             }
-            /**
-             * Event fired by the {@link #execute} method.
-             *
-             * It allows to execute an action after executing the {@link ~ListCommand#execute} method, for example adjusting
-             * attributes of changed blocks.
-             *
-             * @protected
-             * @event _executeCleanup
-             */
-            this.fire('_executeCleanup', blocks);
         });
     }
+    /**
+     * Fires the `afterExecute` event.
+     *
+     * @param changedBlocks The changed list elements.
+     */
+    _fireAfterExecute(changedBlocks) {
+        this.fire('afterExecute', sortBlocks(new Set(changedBlocks)));
+    }
     /**
      * Checks the command's {@link #value}.
      *
      * @returns The current value.
      */
     _getValue() {
-        // Check whether closest `listItem` ancestor of the position has a correct type.
-        const listItem = first(this.editor.model.document.selection.getSelectedBlocks());
-        return !!listItem && listItem.is('element', 'listItem') && listItem.getAttribute('listType') == this.type;
+        const selection = this.editor.model.document.selection;
+        const blocks = Array.from(selection.getSelectedBlocks());
+        if (!blocks.length) {
+            return false;
+        }
+        for (const block of blocks) {
+            if (block.getAttribute('listType') != this.type) {
+                return false;
+            }
+        }
+        return true;
     }
     /**
      * Checks whether the command can be enabled in the current context.
@@ -205,70 +129,22 @@ export default class ListCommand extends Command {
      * @returns Whether the command should be enabled.
      */
     _checkEnabled() {
+        const model = this.editor.model;
+        const schema = model.schema;
+        const selection = model.document.selection;
+        const blocks = Array.from(selection.getSelectedBlocks());
+        if (!blocks.length) {
+            return false;
+        }
         // If command value is true it means that we are in list item, so the command should be enabled.
         if (this.value) {
             return true;
         }
-        const selection = this.editor.model.document.selection;
-        const schema = this.editor.model.schema;
-        const firstBlock = first(selection.getSelectedBlocks());
-        if (!firstBlock) {
-            return false;
-        }
-        // Otherwise, check if list item can be inserted at the position start.
-        return checkCanBecomeListItem(firstBlock, schema);
-    }
-}
-/**
- * Helper function used when one or more list item have their type changed. Fixes type of other list items
- * that are affected by the change (are in same lists) but are not directly in selection. The function got extracted
- * not to duplicated code, as same fix has to be performed before and after selection.
- *
- * @param blocks Blocks that are in selection.
- * @param isBackward Specified whether fix will be applied for blocks before first selected block (`true`)
- * or blocks after last selected block (`false`).
- * @param lowestIndent Lowest indent among selected blocks.
- */
-function _fixType(blocks, isBackward, lowestIndent) {
-    // We need to check previous sibling of first changed item and next siblings of last changed item.
-    const startingItem = isBackward ? blocks[0] : blocks[blocks.length - 1];
-    if (startingItem.is('element', 'listItem')) {
-        let item = startingItem[isBackward ? 'previousSibling' : 'nextSibling'];
-        // During processing items, keeps the lowest indent of already processed items.
-        // This saves us from changing too many items.
-        // Following example is for going forward as it is easier to read, however same applies to going backward.
-        // * ------
-        //   * ------
-        //     * --[---
-        //   * ------		<-- `lowestIndent` should be 1
-        //     * --]---		<-- `startingItem`, `currentIndent` = 2, `lowestIndent` == 1
-        //     * ------		<-- should be fixed, `indent` == 2 == `currentIndent`
-        //   * ------		<-- should be fixed, set `currentIndent` to 1, `indent` == 1 == `currentIndent`
-        //     * ------		<-- should not be fixed, item is in different list, `indent` = 2, `indent` != `currentIndent`
-        //   * ------		<-- should be fixed, `indent` == 1 == `currentIndent`
-        // * ------			<-- break loop (`indent` < `lowestIndent`)
-        let currentIndent = startingItem.getAttribute('listIndent');
-        // Look back until a list item with indent lower than reference `lowestIndent`.
-        // That would be the parent of nested sublist which contains item having `lowestIndent`.
-        while (item && item.is('element', 'listItem') && item.getAttribute('listIndent') >= lowestIndent) {
-            if (currentIndent > item.getAttribute('listIndent')) {
-                currentIndent = item.getAttribute('listIndent');
-            }
-            // Found an item that is in the same nested sublist.
-            if (item.getAttribute('listIndent') == currentIndent) {
-                // Just add the item to selected blocks like it was selected by the user.
-                blocks[isBackward ? 'unshift' : 'push'](item);
+        for (const block of blocks) {
+            if (schema.checkAttribute(block, 'listType') || canBecomeSimpleListItem(block, schema)) {
+                return true;
             }
-            item = item[isBackward ? 'previousSibling' : 'nextSibling'];
         }
+        return false;
     }
 }
-/**
- * Checks whether the given block can be replaced by a listItem.
- *
- * @param block A block to be tested.
- * @param schema The schema of the document.
- */
-function checkCanBecomeListItem(block, schema) {
-    return schema.checkChild(block.parent, 'listItem') && !schema.isObject(block);
-}

package/src/list/listediting.d.ts

@@ -1,18 +1,35 @@
 /**
- * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
  * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
  */
-import ListUtils from './listutils';
-import { Plugin } from 'ckeditor5/src/core';
-import { Enter } from 'ckeditor5/src/enter';
-import { Delete } from 'ckeditor5/src/typing';
+/**
+ * @module list/list/listediting
+ */
+import { Plugin, type Editor } from 'ckeditor5/src/core.js';
+import type { DowncastWriter, Element, ViewElement, ViewAttributeElement, Writer } from 'ckeditor5/src/engine.js';
+import { Delete } from 'ckeditor5/src/typing.js';
+import { Enter } from 'ckeditor5/src/enter.js';
+import ListUtils from './listutils.js';
+import { ListBlocksIterable } from './utils/listwalker.js';
+import { ClipboardPipeline } from 'ckeditor5/src/clipboard.js';
+import '../../theme/documentlist.css';
 import '../../theme/list.css';
 /**
- * The engine of the list feature. It handles creating, editing and removing lists and list items.
- *
- * It registers the `'numberedList'`, `'bulletedList'`, `'indentList'` and `'outdentList'` commands.
+ * Map of model attributes applicable to list blocks.
+ */
+export interface ListItemAttributesMap {
+    listType?: 'numbered' | 'bulleted' | 'todo';
+    listIndent?: number;
+    listItemId?: string;
+}
+/**
+ * The editing part of the document-list feature. It handles creating, editing and removing lists and list items.
  */
 export default class ListEditing extends Plugin {
+    /**
+     * The list of registered downcast strategies.
+     */
+    private readonly _downcastStrategies;
     /**
      * @inheritDoc
      */
@@ -20,7 +37,11 @@ export default class ListEditing extends Plugin {
     /**
      * @inheritDoc
      */
-    static get requires(): readonly [typeof Enter, typeof Delete, typeof ListUtils];
+    static get requires(): readonly [typeof Enter, typeof Delete, typeof ListUtils, typeof ClipboardPipeline];
+    /**
+     * @inheritDoc
+     */
+    constructor(editor: Editor);
     /**
      * @inheritDoc
      */
@@ -29,4 +50,163 @@ export default class ListEditing extends Plugin {
      * @inheritDoc
      */
     afterInit(): void;
+    /**
+     * Registers a downcast strategy.
+     *
+     * **Note**: Strategies must be registered in the `Plugin#init()` phase so that it can be applied
+     * in the `ListEditing#afterInit()`.
+     *
+     * @param strategy The downcast strategy to register.
+     */
+    registerDowncastStrategy(strategy: DowncastStrategy): void;
+    /**
+     * Returns list of model attribute names that should affect downcast conversion.
+     */
+    getListAttributeNames(): Array<string>;
+    /**
+     * Attaches the listener to the {@link module:engine/view/document~Document#event:delete} event and handles backspace/delete
+     * keys in and around document lists.
+     */
+    private _setupDeleteIntegration;
+    /**
+     * Attaches a listener to the {@link module:engine/view/document~Document#event:enter} event and handles enter key press
+     * in document lists.
+     */
+    private _setupEnterIntegration;
+    /**
+     * Attaches a listener to the {@link module:engine/view/document~Document#event:tab} event and handles tab key and tab+shift keys
+     * presses in document lists.
+     */
+    private _setupTabIntegration;
+    /**
+     * Registers the conversion helpers for the document-list feature.
+     */
+    private _setupConversion;
+    /**
+     * Registers model post-fixers.
+     */
+    private _setupModelPostFixing;
+    /**
+     * Integrates the feature with the clipboard via {@link module:engine/model/model~Model#insertContent} and
+     * {@link module:engine/model/model~Model#getSelectedContent}.
+     */
+    private _setupClipboardIntegration;
+}
+/**
+ * The attribute to attribute downcast strategy for UL, OL, LI elements.
+ */
+export interface AttributeDowncastStrategy {
+    /**
+     * The scope of the downcast (whether it applies to LI or OL/UL).
+     */
+    scope: 'list' | 'item';
+    /**
+     * The model attribute name.
+     */
+    attributeName: string;
+    /**
+     * Sets the property on the view element.
+     */
+    setAttributeOnDowncast(writer: DowncastWriter, value: unknown, element: ViewElement): void;
+}
+/**
+ * The custom marker downcast strategy.
+ */
+export interface ItemMarkerDowncastStrategy {
+    /**
+     * The scope of the downcast.
+     */
+    scope: 'itemMarker';
+    /**
+     * The model attribute name.
+     */
+    attributeName: string;
+    /**
+     * Creates a view element for a custom item marker.
+     */
+    createElement(writer: DowncastWriter, modelElement: Element, { dataPipeline }: {
+        dataPipeline?: boolean;
+    }): ViewElement | null;
+    /**
+     * Creates an AttributeElement to be used for wrapping a first block of a list item.
+     */
+    createWrapperElement?(writer: DowncastWriter, modelElement: Element, { dataPipeline }: {
+        dataPipeline?: boolean;
+    }): ViewAttributeElement;
+    /**
+     * Should return true if the given list block can be wrapped with the wrapper created by `createWrapperElement()`
+     * or only the marker element should be wrapped.
+     */
+    canWrapElement?(modelElement: Element): boolean;
 }
+/**
+ * The downcast strategy.
+ */
+export type DowncastStrategy = AttributeDowncastStrategy | ItemMarkerDowncastStrategy;
+/**
+ * Event fired on changes detected on the model list element to verify if the view representation of a list element
+ * is representing those attributes.
+ *
+ * It allows triggering a re-wrapping of a list item.
+ *
+ * @internal
+ * @eventName ~ListEditing#postFixer
+ * @param listHead The head element of a list.
+ * @param writer The writer to do changes with.
+ * @param seenIds The set of already known IDs.
+ * @returns If a post-fixer made a change of the model tree, it should return `true`.
+ */
+export type ListEditingPostFixerEvent = {
+    name: 'postFixer';
+    args: [
+        {
+            listNodes: ListBlocksIterable;
+            listHead: Element;
+            writer: Writer;
+            seenIds: Set<string>;
+        }
+    ];
+    return: boolean;
+};
+/**
+ * Event fired on changes detected on the model list element to verify if the view representation of a list element
+ * is representing those attributes.
+ *
+ * It allows triggering a re-wrapping of a list item.
+ *
+ * **Note**: For convenience this event is namespaced and could be captured as `checkAttributes:list` or `checkAttributes:item`.
+ *
+ * @internal
+ * @eventName ~ListEditing#checkAttributes
+ */
+export type ListEditingCheckAttributesEvent = {
+    name: 'checkAttributes' | 'checkAttributes:list' | 'checkAttributes:item';
+    args: [
+        {
+            viewElement: ViewElement & {
+                id?: string;
+            };
+            modelAttributes: ListItemAttributesMap;
+        }
+    ];
+    return: boolean;
+};
+/**
+ * Event fired on changes detected on the model list element to verify if the view representation of a list block element
+ * is representing those attributes.
+ *
+ * It allows triggering a reconversion of a list item block.
+ *
+ * @internal
+ * @eventName ~ListEditing#checkElement
+ */
+export type ListEditingCheckElementEvent = {
+    name: 'checkElement';
+    args: [
+        {
+            viewElement: ViewElement;
+            modelElement: Element;
+        }
+    ];
+    return: boolean;
+};