@ckeditor/ckeditor5-list 39.0.2 → 40.1.0

package/src/documentlist/documentlistediting.js

@@ -16,9 +16,10 @@ import DocumentListSplitCommand from './documentlistsplitcommand';
 import DocumentListUtils from './documentlistutils';
 import { bogusParagraphCreator, listItemDowncastConverter, listItemUpcastConverter, listUpcastCleanList, reconvertItemsOnDataChange } from './converters';
 import { findAndAddListHeadToMap, fixListIndents, fixListItemIds } from './utils/postfixers';
-import { getAllListItemBlocks, isFirstBlockOfListItem, isLastBlockOfListItem, isSingleListItem, getSelectedBlockObject, isListItemBlock, removeListAttributes } from './utils/model';
+import { getAllListItemBlocks, isFirstBlockOfListItem, isLastBlockOfListItem, isSingleListItem, getSelectedBlockObject, isListItemBlock, removeListAttributes, ListItemUid } from './utils/model';
 import { getViewElementIdForListType, getViewElementNameForListType } from './utils/view';
-import ListWalker, { iterateSiblingListBlocks, ListBlocksIterable } from './utils/listwalker';
+import ListWalker, { ListBlocksIterable } from './utils/listwalker';
+import { ClipboardPipeline } from 'ckeditor5/src/clipboard';
 import '../../theme/documentlist.css';
 import '../../theme/list.css';
 /**
@@ -29,13 +30,6 @@ const LIST_BASE_ATTRIBUTES = ['listType', 'listIndent', 'listItemId'];
  * The editing part of the document-list feature. It handles creating, editing and removing lists and list items.
  */
 export default class DocumentListEditing extends Plugin {
-    constructor() {
-        super(...arguments);
-        /**
-         * The list of registered downcast strategies.
-         */
-        this._downcastStrategies = [];
-    }
     /**
      * @inheritDoc
      */
@@ -46,7 +40,18 @@ export default class DocumentListEditing extends Plugin {
      * @inheritDoc
      */
     static get requires() {
-        return [Enter, Delete, DocumentListUtils];
+        return [Enter, Delete, DocumentListUtils, ClipboardPipeline];
+    }
+    /**
+     * @inheritDoc
+     */
+    constructor(editor) {
+        super(editor);
+        /**
+         * The list of registered downcast strategies.
+         */
+        this._downcastStrategies = [];
+        editor.config.define('list.multiBlock', true);
     }
     /**
      * @inheritDoc
@@ -54,6 +59,7 @@ export default class DocumentListEditing extends Plugin {
     init() {
         const editor = this.editor;
         const model = editor.model;
+        const multiBlock = editor.config.get('list.multiBlock');
         if (editor.plugins.has('ListEditing')) {
             /**
              * The `DocumentList` feature can not be loaded together with the `List` plugin.
@@ -63,9 +69,18 @@ export default class DocumentListEditing extends Plugin {
              */
             throw new CKEditorError('document-list-feature-conflict', this, { conflictPlugin: 'ListEditing' });
         }
-        model.schema.extend('$container', { allowAttributes: LIST_BASE_ATTRIBUTES });
-        model.schema.extend('$block', { allowAttributes: LIST_BASE_ATTRIBUTES });
-        model.schema.extend('$blockObject', { allowAttributes: LIST_BASE_ATTRIBUTES });
+        model.schema.register('$listItem', { allowAttributes: LIST_BASE_ATTRIBUTES });
+        if (multiBlock) {
+            model.schema.extend('$container', { allowAttributesOf: '$listItem' });
+            model.schema.extend('$block', { allowAttributesOf: '$listItem' });
+            model.schema.extend('$blockObject', { allowAttributesOf: '$listItem' });
+        }
+        else {
+            model.schema.register('listItem', {
+                inheritAllFrom: '$block',
+                allowAttributesOf: '$listItem'
+            });
+        }
         for (const attribute of LIST_BASE_ATTRIBUTES) {
             model.schema.setAttributeProperties(attribute, {
                 copyOnReplace: true
@@ -76,10 +91,12 @@ export default class DocumentListEditing extends Plugin {
         editor.commands.add('bulletedList', new DocumentListCommand(editor, 'bulleted'));
         editor.commands.add('indentList', new DocumentListIndentCommand(editor, 'forward'));
         editor.commands.add('outdentList', new DocumentListIndentCommand(editor, 'backward'));
-        editor.commands.add('mergeListItemBackward', new DocumentListMergeCommand(editor, 'backward'));
-        editor.commands.add('mergeListItemForward', new DocumentListMergeCommand(editor, 'forward'));
         editor.commands.add('splitListItemBefore', new DocumentListSplitCommand(editor, 'before'));
         editor.commands.add('splitListItemAfter', new DocumentListSplitCommand(editor, 'after'));
+        if (multiBlock) {
+            editor.commands.add('mergeListItemBackward', new DocumentListMergeCommand(editor, 'backward'));
+            editor.commands.add('mergeListItemForward', new DocumentListMergeCommand(editor, 'forward'));
+        }
         this._setupDeleteIntegration();
         this._setupEnterIntegration();
         this._setupTabIntegration();
@@ -121,7 +138,7 @@ export default class DocumentListEditing extends Plugin {
     /**
      * Returns list of model attribute names that should affect downcast conversion.
      */
-    _getListAttributeNames() {
+    getListAttributeNames() {
         return [
             ...LIST_BASE_ATTRIBUTES,
             ...this._downcastStrategies.map(strategy => strategy.attributeName)
@@ -164,7 +181,7 @@ export default class DocumentListEditing extends Plugin {
                     }
                     // Merge block with previous one (on the block level or on the content level).
                     else {
-                        if (!mergeBackwardCommand.isEnabled) {
+                        if (!mergeBackwardCommand || !mergeBackwardCommand.isEnabled) {
                             return;
                         }
                         mergeBackwardCommand.execute({
@@ -180,7 +197,7 @@ export default class DocumentListEditing extends Plugin {
                     if (selection.isCollapsed && !selection.getLastPosition().isAtEnd) {
                         return;
                     }
-                    if (!mergeForwardCommand.isEnabled) {
+                    if (!mergeForwardCommand || !mergeForwardCommand.isEnabled) {
                         return;
                     }
                     mergeForwardCommand.execute({
@@ -281,29 +298,63 @@ export default class DocumentListEditing extends Plugin {
     _setupConversion() {
         const editor = this.editor;
         const model = editor.model;
-        const attributeNames = this._getListAttributeNames();
+        const attributeNames = this.getListAttributeNames();
+        const multiBlock = editor.config.get('list.multiBlock');
+        const elementName = multiBlock ? 'paragraph' : 'listItem';
         editor.conversion.for('upcast')
-            .elementToElement({ view: 'li', model: 'paragraph' })
+            // Convert <li> to a generic paragraph (or listItem element) so the content of <li> is always inside a block.
+            // Setting the listType attribute to let other features (to-do list) know that this is part of a list item.
+            // This is also important to properly handle simple lists so that paragraphs inside a list item won't break the list item.
+            // <li>  <-- converted to listItem
+            //   <p></p> <-- should be also converted to listItem, so it won't split and replace the listItem generated from the above li.
+            .elementToElement({
+            view: 'li',
+            model: (viewElement, { writer }) => writer.createElement(elementName, { listType: '' })
+        })
+            // Convert paragraph to the list block (without list type defined yet).
+            // This is important to properly handle bogus paragraph and to-do lists.
+            // Most of the time the bogus paragraph should not appear in the data of to-do list,
+            // but if there is any marker or an attribute on the paragraph then the bogus paragraph
+            // is preserved in the data, and we need to be able to detect this case.
+            .elementToElement({
+            view: 'p',
+            model: (viewElement, { writer }) => {
+                if (viewElement.parent && viewElement.parent.is('element', 'li')) {
+                    return writer.createElement(elementName, { listType: '' });
+                }
+                return null;
+            },
+            converterPriority: 'high'
+        })
             .add(dispatcher => {
             dispatcher.on('element:li', listItemUpcastConverter());
             dispatcher.on('element:ul', listUpcastCleanList(), { priority: 'high' });
             dispatcher.on('element:ol', listUpcastCleanList(), { priority: 'high' });
         });
+        if (!multiBlock) {
+            editor.conversion.for('downcast')
+                .elementToElement({
+                model: 'listItem',
+                view: 'p'
+            });
+        }
         editor.conversion.for('editingDowncast')
             .elementToElement({
-            model: 'paragraph',
+            model: elementName,
             view: bogusParagraphCreator(attributeNames),
             converterPriority: 'high'
+        })
+            .add(dispatcher => {
+            dispatcher.on('attribute', listItemDowncastConverter(attributeNames, this._downcastStrategies, model));
         });
         editor.conversion.for('dataDowncast')
             .elementToElement({
-            model: 'paragraph',
+            model: elementName,
             view: bogusParagraphCreator(attributeNames, { dataPipeline: true }),
             converterPriority: 'high'
-        });
-        editor.conversion.for('downcast')
+        })
             .add(dispatcher => {
-            dispatcher.on('attribute', listItemDowncastConverter(attributeNames, this._downcastStrategies, model));
+            dispatcher.on('attribute', listItemDowncastConverter(attributeNames, this._downcastStrategies, model, { dataPipeline: true }));
         });
         this.listenTo(model.document, 'change:data', reconvertItemsOnDataChange(model, editor.editing, attributeNames, this), { priority: 'high' });
         // For LI verify if an ID of the attribute element is correct.
@@ -327,7 +378,7 @@ export default class DocumentListEditing extends Plugin {
      */
     _setupModelPostFixing() {
         const model = this.editor.model;
-        const attributeNames = this._getListAttributeNames();
+        const attributeNames = this.getListAttributeNames();
         // Register list fixing.
         // First the low level handler.
         model.document.registerPostFixer(writer => modelChangePostFixer(model, writer, attributeNames, this));
@@ -347,6 +398,7 @@ export default class DocumentListEditing extends Plugin {
      */
     _setupClipboardIntegration() {
         const model = this.editor.model;
+        const clipboardPipeline = this.editor.plugins.get('ClipboardPipeline');
         this.listenTo(model, 'insertContent', createModelIndentPasteFixer(model), { priority: 'high' });
         // To enhance the UX, the editor should not copy list attributes to the clipboard if the selection
         // started and ended in the same list item.
@@ -375,12 +427,27 @@ export default class DocumentListEditing extends Plugin {
         //	                       │  * bar]             │ * bar             │
         //	                       └─────────────────────┴───────────────────┘
         //
-        // See https://github.com/ckeditor/ckeditor5/issues/11608.
-        this.listenTo(model, 'getSelectedContent', (evt, [selection]) => {
-            const isSingleListItemSelected = isSingleListItem(Array.from(selection.getSelectedBlocks()));
-            if (isSingleListItemSelected) {
-                model.change(writer => removeListAttributes(Array.from(evt.return.getChildren()), writer));
-            }
+        // See https://github.com/ckeditor/ckeditor5/issues/11608, https://github.com/ckeditor/ckeditor5/issues/14969
+        this.listenTo(clipboardPipeline, 'outputTransformation', (evt, data) => {
+            model.change(writer => {
+                // Remove last block if it's empty.
+                const allContentChildren = Array.from(data.content.getChildren());
+                const lastItem = allContentChildren[allContentChildren.length - 1];
+                if (allContentChildren.length > 1 && lastItem.is('element') && lastItem.isEmpty) {
+                    const contentChildrenExceptLastItem = allContentChildren.slice(0, -1);
+                    if (contentChildrenExceptLastItem.every(isListItemBlock)) {
+                        writer.remove(lastItem);
+                    }
+                }
+                // Copy/cut only content of a list item (for drag-drop move the whole list item).
+                if (data.method == 'copy' || data.method == 'cut') {
+                    const allChildren = Array.from(data.content.getChildren());
+                    const isSingleListItemSelected = isSingleListItem(allChildren);
+                    if (isSingleListItemSelected) {
+                        removeListAttributes(allChildren, writer);
+                    }
+                }
+            });
         });
     }
 }
@@ -419,6 +486,7 @@ export default class DocumentListEditing extends Plugin {
 function modelChangePostFixer(model, writer, attributeNames, documentListEditing) {
     const changes = model.document.differ.getChanges();
     const itemToListHead = new Map();
+    const multiBlock = documentListEditing.editor.config.get('list.multiBlock');
     let applied = false;
     for (const entry of changes) {
         if (entry.type == 'insert' && entry.name != '$text') {
@@ -455,6 +523,18 @@ function modelChangePostFixer(model, writer, attributeNames, documentListEditing
                 findAndAddListHeadToMap(entry.range.start.getShiftedBy(1), itemToListHead);
             }
         }
+        // Make sure that there is no left over listItem element without attributes or a block with list attributes that is not a listItem.
+        if (!multiBlock && entry.type == 'attribute' && LIST_BASE_ATTRIBUTES.includes(entry.attributeKey)) {
+            const element = entry.range.start.nodeAfter;
+            if (entry.attributeNewValue === null && element && element.is('element', 'listItem')) {
+                writer.rename(element, 'paragraph');
+                applied = true;
+            }
+            else if (entry.attributeOldValue === null && element && element.is('element') && element.name != 'listItem') {
+                writer.rename(element, 'listItem');
+                applied = true;
+            }
+        }
     }
     // Make sure that IDs are not shared by split list.
     const seenIds = new Set();
@@ -476,65 +556,66 @@ function modelChangePostFixer(model, writer, attributeNames, documentListEditing
  * Example:
  *
  * ```xml
- * <paragraph listType="bulleted" listItemId="a" listIndent=0>A</paragraph>
- * <paragraph listType="bulleted" listItemId="b" listIndent=1>B^</paragraph>
- * // At ^ paste:  <paragraph listType="bulleted" listItemId="x" listIndent=4>X</paragraph>
- * //              <paragraph listType="bulleted" listItemId="y" listIndent=5>Y</paragraph>
- * <paragraph listType="bulleted" listItemId="c" listIndent=2>C</paragraph>
+ * <paragraph listType="bulleted" listItemId="a" listIndent="0">A</paragraph>
+ * <paragraph listType="bulleted" listItemId="b" listIndent="1">B^</paragraph>
+ * // At ^ paste:  <paragraph listType="numbered" listItemId="x" listIndent="0">X</paragraph>
+ * //              <paragraph listType="numbered" listItemId="y" listIndent="1">Y</paragraph>
+ * <paragraph listType="bulleted" listItemId="c" listIndent="2">C</paragraph>
  * ```
  *
  * Should become:
  *
  * ```xml
- * <paragraph listType="bulleted" listItemId="a" listIndent=0>A</paragraph>
- * <paragraph listType="bulleted" listItemId="b" listIndent=1>BX</paragraph>
- * <paragraph listType="bulleted" listItemId="y" listIndent=2>Y/paragraph>
- * <paragraph listType="bulleted" listItemId="c" listIndent=2>C</paragraph>
+ * <paragraph listType="bulleted" listItemId="a" listIndent="0">A</paragraph>
+ * <paragraph listType="bulleted" listItemId="b" listIndent="1">BX</paragraph>
+ * <paragraph listType="bulleted" listItemId="y" listIndent="2">Y/paragraph>
+ * <paragraph listType="bulleted" listItemId="c" listIndent="2">C</paragraph>
  * ```
  */
 function createModelIndentPasteFixer(model) {
     return (evt, [content, selectable]) => {
-        // Check whether inserted content starts from a `listItem`. If it does not, it means that there are some other
-        // elements before it and there is no need to fix indents, because even if we insert that content into a list,
-        // that list will be broken.
-        // Note: we also need to handle singular elements because inserting item with indent 0 into 0,1,[],2
-        // would create incorrect model.
-        const item = content.is('documentFragment') ? content.getChild(0) : content;
-        if (!isListItemBlock(item)) {
+        const items = content.is('documentFragment') ?
+            Array.from(content.getChildren()) :
+            [content];
+        if (!items.length) {
             return;
         }
-        let selection;
-        if (!selectable) {
-            selection = model.document.selection;
-        }
-        else {
-            selection = model.createSelection(selectable);
-        }
-        // Get a reference list item. Inserted list items will be fixed according to that item.
-        const pos = selection.getFirstPosition();
-        let refItem = null;
-        if (isListItemBlock(pos.parent)) {
-            refItem = pos.parent;
+        const selection = selectable ?
+            model.createSelection(selectable) :
+            model.document.selection;
+        const position = selection.getFirstPosition();
+        // Get a reference list item. Attributes of the inserted list items will be fixed according to that item.
+        let refItem;
+        if (isListItemBlock(position.parent)) {
+            refItem = position.parent;
         }
-        else if (isListItemBlock(pos.nodeBefore)) {
-            refItem = pos.nodeBefore;
+        else if (isListItemBlock(position.nodeBefore)) {
+            refItem = position.nodeBefore;
         }
-        // If there is `refItem` it means that we do insert list items into an existing list.
-        if (!refItem) {
-            return;
-        }
-        // First list item in `data` has indent equal to 0 (it is a first list item). It should have indent equal
-        // to the indent of reference item. We have to fix the first item and all of it's children and following siblings.
-        // Indent of all those items has to be adjusted to reference item.
-        const indentChange = refItem.getAttribute('listIndent') - item.getAttribute('listIndent');
-        // Fix only if there is anything to fix.
-        if (indentChange <= 0) {
-            return;
+        else {
+            return; // Content is not copied into a list.
         }
         model.change(writer => {
-            // Adjust indent of all "first" list items in inserted data.
-            for (const { node } of iterateSiblingListBlocks(item, 'forward')) {
-                writer.setAttribute('listIndent', node.getAttribute('listIndent') + indentChange, node);
+            const refType = refItem.getAttribute('listType');
+            const refIndent = refItem.getAttribute('listIndent');
+            const firstElementIndent = items[0].getAttribute('listIndent') || 0;
+            const indentDiff = Math.max(refIndent - firstElementIndent, 0);
+            for (const item of items) {
+                const isListItem = isListItemBlock(item);
+                if (refItem.is('element', 'listItem') && item.is('element', 'paragraph')) {
+                    /**
+                     * When paragraphs or a plain text list is pasted into a simple list, convert
+                     * the `<paragraphs>' to `<listItem>' to avoid breaking the target list.
+                     *
+                     * See https://github.com/ckeditor/ckeditor5/issues/13826.
+                     */
+                    writer.rename(item, 'listItem');
+                }
+                writer.setAttributes({
+                    listIndent: (isListItem ? item.getAttribute('listIndent') : 0) + indentDiff,
+                    listItemId: isListItem ? item.getAttribute('listItemId') : ListItemUid.next(),
+                    listType: refType
+                }, item);
             }
         });
     };

package/src/documentlist/utils/listwalker.d.ts

@@ -138,4 +138,8 @@ export interface ListIteratorValue {
      * The previous list node.
      */
     previous: ListElement | null;
+    /**
+     * The previous list node at the same indent as current node.
+     */
+    previousNodeInList: ListElement | null;
 }

package/src/documentlist/utils/listwalker.js

@@ -132,9 +132,29 @@ export default class ListWalker {
  */
 export function* iterateSiblingListBlocks(node, direction = 'forward') {
     const isForward = direction == 'forward';
+    const previousNodesByIndent = []; // Last seen nodes of lower indented lists.
     let previous = null;
     while (isListItemBlock(node)) {
-        yield { node, previous };
+        let previousNodeInList = null; // It's like `previous` but has the same indent as current node.
+        if (previous) {
+            const nodeIndent = node.getAttribute('listIndent');
+            const previousNodeIndent = previous.getAttribute('listIndent');
+            // Let's find previous node for the same indent.
+            // We're going to need that when we get back to previous indent.
+            if (nodeIndent > previousNodeIndent) {
+                previousNodesByIndent[previousNodeIndent] = previous;
+            }
+            // Restore the one for given indent.
+            else if (nodeIndent < previousNodeIndent) {
+                previousNodeInList = previousNodesByIndent[nodeIndent];
+                previousNodesByIndent.length = nodeIndent;
+            }
+            // Same indent.
+            else {
+                previousNodeInList = previous;
+            }
+        }
+        yield { node, previous, previousNodeInList };
         previous = node;
         node = isForward ? node.nextSibling : node.previousSibling;
     }

package/src/documentlist/utils/model.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module list/documentlist/utils/model
  */
-import type { DocumentFragment, Element, Model, Node, Writer, Item } from 'ckeditor5/src/engine';
+import type { DocumentFragment, Element, Model, Node, Writer, Item, Schema } from 'ckeditor5/src/engine';
 import { type ArrayOrItem } from 'ckeditor5/src/utils';
 /**
  * The list item ID generator.
@@ -28,7 +28,7 @@ export declare class ListItemUid {
 export interface ListElement extends Element {
     getAttribute(key: 'listItemId'): string;
     getAttribute(key: 'listIndent'): number;
-    getAttribute(key: 'listType'): 'numbered' | 'bulleted';
+    getAttribute(key: 'listType'): 'numbered' | 'bulleted' | 'todo';
     getAttribute(key: string): unknown;
 }
 /**
@@ -191,3 +191,12 @@ export declare function sortBlocks<T extends Element>(blocks: Iterable<T>): Arra
  * @returns Selected block object or `null`.
  */
 export declare function getSelectedBlockObject(model: Model): Element | null;
+/**
+ * Checks whether the given block can be replaced by a listItem.
+ *
+ * Note that this is possible only when multiBlock = false option is set in feature config.
+ *
+ * @param block A block to be tested.
+ * @param schema The schema of the document.
+ */
+export declare function canBecomeSimpleListItem(block: Element, schema: Schema): boolean;

package/src/documentlist/utils/model.js

@@ -282,6 +282,13 @@ export function outdentBlocksWithMerge(blocks, writer) {
  */
 export function removeListAttributes(blocks, writer) {
     blocks = toArray(blocks);
+    // Convert simple list items to plain paragraphs.
+    for (const block of blocks) {
+        if (block.is('element', 'listItem')) {
+            writer.rename(block, 'paragraph');
+        }
+    }
+    // Remove list attributes.
     for (const block of blocks) {
         for (const attributeKey of block.getAttributeKeys()) {
             if (attributeKey.startsWith('list')) {
@@ -416,7 +423,20 @@ export function getSelectedBlockObject(model) {
     }
     return null;
 }
-// Merges a given block to the given parent block if parent is a list item and there is no more blocks in the same item.
+/**
+ * Checks whether the given block can be replaced by a listItem.
+ *
+ * Note that this is possible only when multiBlock = false option is set in feature config.
+ *
+ * @param block A block to be tested.
+ * @param schema The schema of the document.
+ */
+export function canBecomeSimpleListItem(block, schema) {
+    return schema.checkChild(block.parent, 'listItem') && schema.checkChild(block, '$text') && !schema.isObject(block);
+}
+/**
+ * Merges a given block to the given parent block if parent is a list item and there is no more blocks in the same item.
+ */
 function mergeListItemIfNotLast(block, parentBlock, writer) {
     const parentItemBlocks = getListItemBlocks(parentBlock, { direction: 'forward' });
     // Merge with parent only if outdented item wasn't the last one in its parent.

package/src/documentlist/utils/postfixers.js

@@ -101,6 +101,14 @@ export function fixListItemIds(listNodes, seenIds, writer) {
             listItemId = ListItemUid.next();
         }
         seenIds.add(listItemId);
+        // Make sure that all items in a simple list have unique IDs.
+        if (node.is('element', 'listItem')) {
+            if (node.getAttribute('listItemId') != listItemId) {
+                writer.setAttribute('listItemId', listItemId, node);
+                applied = true;
+            }
+            continue;
+        }
         for (const block of getListItemBlocks(node, { direction: 'forward' })) {
             visited.add(block);
             // Use a new ID if a block of a bigger list item has different type.

package/src/documentlist/utils/view.d.ts

@@ -60,7 +60,7 @@ export declare function getIndent(listItem: ViewElement): number;
  *
  * @internal
  */
-export declare function createListElement(writer: DowncastWriter, indent: number, type: 'bulleted' | 'numbered', id?: string): ViewAttributeElement;
+export declare function createListElement(writer: DowncastWriter, indent: number, type: 'bulleted' | 'numbered' | 'todo', id?: string): ViewAttributeElement;
 /**
  * Creates a list item attribute element (li).
  *
@@ -72,10 +72,10 @@ export declare function createListItemElement(writer: DowncastWriter, indent: nu
  *
  * @internal
  */
-export declare function getViewElementNameForListType(type?: 'bulleted' | 'numbered'): 'ol' | 'ul';
+export declare function getViewElementNameForListType(type?: 'bulleted' | 'numbered' | 'todo'): 'ol' | 'ul';
 /**
  * Returns a view element ID for the given list type and indent.
  *
  * @internal
  */
-export declare function getViewElementIdForListType(type?: 'bulleted' | 'numbered', indent?: number): string;
+export declare function getViewElementIdForListType(type?: 'bulleted' | 'numbered' | 'todo', indent?: number): string;

package/src/documentlistproperties/documentlistpropertiesediting.js

@@ -38,12 +38,10 @@ export default class DocumentListPropertiesEditing extends Plugin {
      */
     constructor(editor) {
         super(editor);
-        editor.config.define('list', {
-            properties: {
-                styles: true,
-                startIndex: false,
-                reversed: false
-            }
+        editor.config.define('list.properties', {
+            styles: true,
+            startIndex: false,
+            reversed: false
         });
     }
     /**
@@ -57,9 +55,7 @@ export default class DocumentListPropertiesEditing extends Plugin {
         const strategies = createAttributeStrategies(enabledProperties);
         for (const strategy of strategies) {
             strategy.addCommand(editor);
-            model.schema.extend('$container', { allowAttributes: strategy.attributeName });
-            model.schema.extend('$block', { allowAttributes: strategy.attributeName });
-            model.schema.extend('$blockObject', { allowAttributes: strategy.attributeName });
+            model.schema.extend('$listItem', { allowAttributes: strategy.attributeName });
             // Register downcast strategy.
             documentListEditing.registerDowncastStrategy({
                 scope: 'list',
@@ -122,29 +118,7 @@ export default class DocumentListPropertiesEditing extends Plugin {
         });
         // Make sure that all items in a single list (items at the same level & listType) have the same properties.
         documentListEditing.on('postFixer', (evt, { listNodes, writer }) => {
-            const previousNodesByIndent = []; // Last seen nodes of lower indented lists.
-            for (const { node, previous } of listNodes) {
-                // For the first list block there is nothing to compare with.
-                if (!previous) {
-                    continue;
-                }
-                const nodeIndent = node.getAttribute('listIndent');
-                const previousNodeIndent = previous.getAttribute('listIndent');
-                let previousNodeInList = null; // It's like `previous` but has the same indent as current node.
-                // Let's find previous node for the same indent.
-                // We're going to need that when we get back to previous indent.
-                if (nodeIndent > previousNodeIndent) {
-                    previousNodesByIndent[previousNodeIndent] = previous;
-                }
-                // Restore the one for given indent.
-                else if (nodeIndent < previousNodeIndent) {
-                    previousNodeInList = previousNodesByIndent[nodeIndent];
-                    previousNodesByIndent.length = nodeIndent;
-                }
-                // Same indent.
-                else {
-                    previousNodeInList = previous;
-                }
+            for (const { node, previousNodeInList } of listNodes) {
                 // This is a first item of a nested list.
                 if (!previousNodeInList) {
                     continue;
@@ -187,10 +161,13 @@ function createAttributeStrategies(enabledProperties) {
                 }
                 editor.commands.add('listStyle', new DocumentListStyleCommand(editor, DEFAULT_LIST_TYPE, supportedTypes));
             },
-            appliesToListItem() {
-                return true;
+            appliesToListItem(item) {
+                return item.getAttribute('listType') == 'numbered' || item.getAttribute('listType') == 'bulleted';
             },
             hasValidAttribute(item) {
+                if (!this.appliesToListItem(item)) {
+                    return !item.hasAttribute('listStyle');
+                }
                 if (!item.hasAttribute('listStyle')) {
                     return false;
                 }

package/src/index.d.ts

@@ -24,6 +24,8 @@ export { default as ListPropertiesUI } from './listproperties/listpropertiesui';
 export { default as TodoList } from './todolist';
 export { default as TodoListEditing } from './todolist/todolistediting';
 export { default as TodoListUI } from './todolist/todolistui';
+export { default as TodoDocumentList } from './tododocumentlist';
+export { default as TodoDocumentListEditing } from './tododocumentlist/tododocumentlistediting';
 export type { ListConfig, ListPropertiesConfig } from './listconfig';
 export type { default as ListStyle } from './liststyle';
 export type { default as DocumentListCommand } from './documentlist/documentlistcommand';
@@ -37,4 +39,5 @@ export type { default as ListReversedCommand } from './listproperties/listrevers
 export type { default as ListStartCommand } from './listproperties/liststartcommand';
 export type { default as ListStyleCommand } from './listproperties/liststylecommand';
 export type { default as CheckTodoListCommand } from './todolist/checktodolistcommand';
+export type { default as CheckTodoDocumentListCommand } from './tododocumentlist/checktododocumentlistcommand';
 import './augmentation';

package/src/index.js

@@ -24,4 +24,6 @@ export { default as ListPropertiesUI } from './listproperties/listpropertiesui';
 export { default as TodoList } from './todolist';
 export { default as TodoListEditing } from './todolist/todolistediting';
 export { default as TodoListUI } from './todolist/todolistui';
+export { default as TodoDocumentList } from './tododocumentlist';
+export { default as TodoDocumentListEditing } from './tododocumentlist/tododocumentlistediting';
 import './augmentation';

package/src/listconfig.d.ts

@@ -30,6 +30,16 @@ export interface ListConfig {
      * Read more in {@link module:list/listconfig~ListPropertiesConfig}.
      */
     properties?: ListPropertiesConfig;
+    /**
+     * Allows multiple blocks in single list item.
+     *
+     * With this option enabled you can have block widgets, for example images or even tables, within a list item.
+     *
+     * **Note:** This is enabled by default.
+     *
+     * @default true
+     */
+    multiBlock?: boolean;
 }
 /**
  * The configuration of the {@link module:list/listproperties~ListProperties list properties} feature and the