@ckeditor/ckeditor5-list 40.2.0 → 41.1.0

package/src/{list/indentcommand.d.ts → legacylist/legacyindentcommand.d.ts}

@@ -1,12 +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';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
 /**
- * The list indent command. It is used by the {@link module:list/list~List list feature}.
+ * The list indent command. It is used by the {@link module:list/legacylist~LegacyList legacy list feature}.
  */
-export default class IndentCommand extends Command {
+export default class LegacyIndentCommand extends Command {
     /**
      * Determines by how much the command will change the list item's indent attribute.
      */

package/src/{list/indentcommand.js → legacylist/legacyindentcommand.js}

@@ -1,13 +1,13 @@
 /**
- * @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 { first } from 'ckeditor5/src/utils.js';
 /**
- * The list indent command. It is used by the {@link module:list/list~List list feature}.
+ * The list indent command. It is used by the {@link module:list/legacylist~LegacyList legacy list feature}.
  */
-export default class IndentCommand extends Command {
+export default class LegacyIndentCommand extends Command {
     /**
      * Creates an instance of the command.
      *

package/src/{documentlist/documentlistcommand.d.ts → legacylist/legacylistcommand.d.ts}

@@ -1,16 +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.js';
 /**
- * @module list/documentlist/documentlistcommand
+ * The list command. It is used by the {@link module:list/legacylist~LegacyList legacy list feature}.
  */
-import type { Element } from 'ckeditor5/src/engine';
-import { Command, type Editor } from 'ckeditor5/src/core';
-/**
- * The list command. It is used by the {@link module:list/documentlist~DocumentList document list feature}.
- */
-export default class DocumentListCommand extends Command {
+export default class LegacyListCommand extends Command {
     /**
      * The type of the list created by the command.
      */
@@ -18,7 +14,6 @@ export default class DocumentListCommand 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;
@@ -37,21 +32,14 @@ export default class DocumentListCommand 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}.
      *
@@ -65,16 +53,3 @@ export default class DocumentListCommand extends Command {
      */
     private _checkEnabled;
 }
-/**
- * Event fired by the {@link ~DocumentListCommand#execute} method.
- *
- * It allows to execute an action after executing the {@link ~DocumentListCommand#execute} method,
- * for example adjusting attributes of changed list items.
- *
- * @internal
- * @eventName ~DocumentListCommand#afterExecute
- */
-export type DocumentListCommandAfterExecuteEvent = {
-    name: 'afterExecute';
-    args: [changedBlocks: Array<Element>];
-};

package/src/legacylist/legacylistcommand.js

@@ -0,0 +1,274 @@
+/**
+ * @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.js';
+import { first } from 'ckeditor5/src/utils.js';
+/**
+ * The list command. It is used by the {@link module:list/legacylist~LegacyList legacy list feature}.
+ */
+export default class LegacyListCommand extends Command {
+    /**
+     * Creates an instance of the command.
+     *
+     * @param editor The editor instance.
+     * @param type List type that will be handled by this command.
+     */
+    constructor(editor, type) {
+        super(editor);
+        this.type = type;
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        this.value = this._getValue();
+        this.isEnabled = this._checkEnabled();
+    }
+    /**
+     * Executes the list command.
+     *
+     * @fires execute
+     * @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
+     * 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 blocks = Array.from(document.selection.getSelectedBlocks())
+            .filter(block => checkCanBecomeListItem(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);
+                }
+            }
+            // 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');
+                    }
+                }
+                // 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);
+            }
+            // 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);
+                }
+            }
+            /**
+             * 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);
+        });
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Checks whether the command can be enabled in the current context.
+     *
+     * @returns Whether the command should be enabled.
+     */
+    _checkEnabled() {
+        // 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);
+            }
+            item = item[isBackward ? 'previousSibling' : 'nextSibling'];
+        }
+    }
+}
+/**
+ * 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/legacylist/legacylistediting.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 LegacyListUtils from './legacylistutils.js';
+import { Plugin } from 'ckeditor5/src/core.js';
+import { Enter } from 'ckeditor5/src/enter.js';
+import { Delete } from 'ckeditor5/src/typing.js';
+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.
+ */
+export default class LegacyListEditing extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "LegacyListEditing";
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof Enter, typeof Delete, typeof LegacyListUtils];
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * @inheritDoc
+     */
+    afterInit(): void;
+}

package/src/legacylist/legacylistediting.js

@@ -0,0 +1,161 @@
+/**
+ * @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
+ */
+/**
+ * @module list/legacylist/legacylistediting
+ */
+import LegacyListCommand from './legacylistcommand.js';
+import LegacyIndentCommand from './legacyindentcommand.js';
+import LegacyListUtils from './legacylistutils.js';
+import { Plugin } from 'ckeditor5/src/core.js';
+import { Enter } from 'ckeditor5/src/enter.js';
+import { Delete } from 'ckeditor5/src/typing.js';
+import { cleanList, cleanListItem, modelViewInsertion, modelViewChangeType, modelViewMergeAfterChangeType, modelViewMergeAfter, modelViewRemove, modelViewSplitOnInsert, modelViewChangeIndent, modelChangePostFixer, modelIndentPasteFixer, viewModelConverter, modelToViewPosition, viewToModelPosition } from './legacyconverters.js';
+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.
+ */
+export default class LegacyListEditing extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'LegacyListEditing';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [Enter, Delete, LegacyListUtils];
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        // Schema.
+        // Note: in case `$block` will ever be allowed in `listItem`, keep in mind that this feature
+        // uses `Selection#getSelectedBlocks()` without any additional processing to obtain all selected list items.
+        // If there are blocks allowed inside list item, algorithms using `getSelectedBlocks()` will have to be modified.
+        editor.model.schema.register('listItem', {
+            inheritAllFrom: '$block',
+            allowAttributes: ['listType', 'listIndent']
+        });
+        // Converters.
+        const data = editor.data;
+        const editing = editor.editing;
+        editor.model.document.registerPostFixer(writer => modelChangePostFixer(editor.model, writer));
+        editing.mapper.registerViewToModelLength('li', getViewListItemLength);
+        data.mapper.registerViewToModelLength('li', getViewListItemLength);
+        editing.mapper.on('modelToViewPosition', modelToViewPosition(editing.view));
+        editing.mapper.on('viewToModelPosition', viewToModelPosition(editor.model));
+        data.mapper.on('modelToViewPosition', modelToViewPosition(editing.view));
+        editor.conversion.for('editingDowncast')
+            .add(dispatcher => {
+            dispatcher.on('insert', modelViewSplitOnInsert, { priority: 'high' });
+            dispatcher.on('insert:listItem', modelViewInsertion(editor.model));
+            dispatcher.on('attribute:listType:listItem', modelViewChangeType, { priority: 'high' });
+            dispatcher.on('attribute:listType:listItem', modelViewMergeAfterChangeType, { priority: 'low' });
+            dispatcher.on('attribute:listIndent:listItem', modelViewChangeIndent(editor.model));
+            dispatcher.on('remove:listItem', modelViewRemove(editor.model));
+            dispatcher.on('remove', modelViewMergeAfter, { priority: 'low' });
+        });
+        editor.conversion.for('dataDowncast')
+            .add(dispatcher => {
+            dispatcher.on('insert', modelViewSplitOnInsert, { priority: 'high' });
+            dispatcher.on('insert:listItem', modelViewInsertion(editor.model));
+        });
+        editor.conversion.for('upcast')
+            .add(dispatcher => {
+            dispatcher.on('element:ul', cleanList, { priority: 'high' });
+            dispatcher.on('element:ol', cleanList, { priority: 'high' });
+            dispatcher.on('element:li', cleanListItem, { priority: 'high' });
+            dispatcher.on('element:li', viewModelConverter);
+        });
+        // Fix indentation of pasted items.
+        editor.model.on('insertContent', modelIndentPasteFixer, { priority: 'high' });
+        // Register commands for numbered and bulleted list.
+        editor.commands.add('numberedList', new LegacyListCommand(editor, 'numbered'));
+        editor.commands.add('bulletedList', new LegacyListCommand(editor, 'bulleted'));
+        // Register commands for indenting.
+        editor.commands.add('indentList', new LegacyIndentCommand(editor, 'forward'));
+        editor.commands.add('outdentList', new LegacyIndentCommand(editor, 'backward'));
+        const viewDocument = editing.view.document;
+        // Overwrite default Enter key behavior.
+        // If Enter key is pressed with selection collapsed in empty list item, outdent it instead of breaking it.
+        this.listenTo(viewDocument, 'enter', (evt, data) => {
+            const doc = this.editor.model.document;
+            const positionParent = doc.selection.getLastPosition().parent;
+            if (doc.selection.isCollapsed && positionParent.name == 'listItem' && positionParent.isEmpty) {
+                this.editor.execute('outdentList');
+                data.preventDefault();
+                evt.stop();
+            }
+        }, { context: 'li' });
+        // Overwrite default Backspace key behavior.
+        // If Backspace key is pressed with selection collapsed on first position in first list item, outdent it. #83
+        this.listenTo(viewDocument, 'delete', (evt, data) => {
+            // Check conditions from those that require less computations like those immediately available.
+            if (data.direction !== 'backward') {
+                return;
+            }
+            const selection = this.editor.model.document.selection;
+            if (!selection.isCollapsed) {
+                return;
+            }
+            const firstPosition = selection.getFirstPosition();
+            if (!firstPosition.isAtStart) {
+                return;
+            }
+            const positionParent = firstPosition.parent;
+            if (positionParent.name !== 'listItem') {
+                return;
+            }
+            const previousIsAListItem = positionParent.previousSibling && positionParent.previousSibling.name === 'listItem';
+            if (previousIsAListItem) {
+                return;
+            }
+            this.editor.execute('outdentList');
+            data.preventDefault();
+            evt.stop();
+        }, { context: 'li' });
+        this.listenTo(editor.editing.view.document, 'tab', (evt, data) => {
+            const commandName = data.shiftKey ? 'outdentList' : 'indentList';
+            const command = this.editor.commands.get(commandName);
+            if (command.isEnabled) {
+                editor.execute(commandName);
+                data.stopPropagation();
+                data.preventDefault();
+                evt.stop();
+            }
+        }, { context: 'li' });
+    }
+    /**
+     * @inheritDoc
+     */
+    afterInit() {
+        const commands = this.editor.commands;
+        const indent = commands.get('indent');
+        const outdent = commands.get('outdent');
+        if (indent) {
+            indent.registerChildCommand(commands.get('indentList'));
+        }
+        if (outdent) {
+            outdent.registerChildCommand(commands.get('outdentList'));
+        }
+    }
+}
+function getViewListItemLength(element) {
+    let length = 1;
+    for (const child of element.getChildren()) {
+        if (child.name == 'ul' || child.name == 'ol') {
+            for (const item of child.getChildren()) {
+                length += getViewListItemLength(item);
+            }
+        }
+    }
+    return length;
+}

package/src/legacylist/legacylistutils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @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
+ */
+/**
+ * @module list/legacylist/legacylistutils
+ */
+import type { Element, Model, Position } from 'ckeditor5/src/engine.js';
+import { Plugin } from 'ckeditor5/src/core.js';
+/**
+ * A set of helpers related to legacy lists.
+ */
+export default class LegacyListUtils extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "LegacyListUtils";
+    /**
+     * Checks whether the given list-style-type is supported by numbered or bulleted list.
+     */
+    getListTypeFromListStyleType(listStyleType: string): 'bulleted' | 'numbered' | null;
+    /**
+     * Returns an array with all `listItem` elements in the model selection.
+     *
+     * It returns all the items even if only a part of the list is selected, including items that belong to nested lists.
+     * If no list is selected, it returns an empty array.
+     * The order of the elements is not specified.
+     */
+    getSelectedListItems(model: Model): Array<Element>;
+    /**
+     * Returns an array with all `listItem` elements that represent the same list.
+     *
+     * It means that values of `listIndent`, `listType`, `listStyle`, `listReversed` and `listStart` for all items are equal.
+     *
+     * Additionally, if the `position` is inside a list item, that list item will be returned as well.
+     *
+     * @param position Starting position.
+     * @param direction Walking direction.
+     */
+    getSiblingNodes(position: Position, direction: 'forward' | 'backward'): Array<Element>;
+}

package/src/legacylist/legacylistutils.js

@@ -0,0 +1,46 @@
+/**
+ * @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 { Plugin } from 'ckeditor5/src/core.js';
+import { getListTypeFromListStyleType, getSelectedListItems, getSiblingNodes } from './legacyutils.js';
+/**
+ * A set of helpers related to legacy lists.
+ */
+export default class LegacyListUtils extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'LegacyListUtils';
+    }
+    /**
+     * Checks whether the given list-style-type is supported by numbered or bulleted list.
+     */
+    getListTypeFromListStyleType(listStyleType) {
+        return getListTypeFromListStyleType(listStyleType);
+    }
+    /**
+     * Returns an array with all `listItem` elements in the model selection.
+     *
+     * It returns all the items even if only a part of the list is selected, including items that belong to nested lists.
+     * If no list is selected, it returns an empty array.
+     * The order of the elements is not specified.
+     */
+    getSelectedListItems(model) {
+        return getSelectedListItems(model);
+    }
+    /**
+     * Returns an array with all `listItem` elements that represent the same list.
+     *
+     * It means that values of `listIndent`, `listType`, `listStyle`, `listReversed` and `listStart` for all items are equal.
+     *
+     * Additionally, if the `position` is inside a list item, that list item will be returned as well.
+     *
+     * @param position Starting position.
+     * @param direction Walking direction.
+     */
+    getSiblingNodes(position, direction) {
+        return getSiblingNodes(position, direction);
+    }
+}