@ckeditor/ckeditor5-list 0.0.0-internal-20241017.0

package/src/legacytodolist/legacytodolistconverters.js

@@ -0,0 +1,261 @@
+/**
+ * @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 { createElement } from 'ckeditor5/src/utils.js';
+import { generateLiInUl, injectViewList, positionAfterUiElements, findNestedList } from '../legacylist/legacyutils.js';
+/**
+ * A model-to-view converter for the `listItem` model element insertion.
+ *
+ * It converts the `listItem` model element to an unordered list with a {@link module:engine/view/uielement~UIElement checkbox element}
+ * at the beginning of each list item. It also merges the list with surrounding lists (if available).
+ *
+ * It is used by {@link module:engine/controller/editingcontroller~EditingController}.
+ *
+ * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert
+ * @param model Model instance.
+ * @param onCheckboxChecked Callback function.
+ * @returns Returns a conversion callback.
+ */
+export function modelViewInsertion(model, onCheckboxChecked) {
+    return (evt, data, conversionApi) => {
+        const consumable = conversionApi.consumable;
+        if (!consumable.test(data.item, 'insert') ||
+            !consumable.test(data.item, 'attribute:listType') ||
+            !consumable.test(data.item, 'attribute:listIndent')) {
+            return;
+        }
+        if (data.item.getAttribute('listType') != 'todo') {
+            return;
+        }
+        const modelItem = data.item;
+        consumable.consume(modelItem, 'insert');
+        consumable.consume(modelItem, 'attribute:listType');
+        consumable.consume(modelItem, 'attribute:listIndent');
+        consumable.consume(modelItem, 'attribute:todoListChecked');
+        const viewWriter = conversionApi.writer;
+        const viewItem = generateLiInUl(modelItem, conversionApi);
+        const isChecked = !!modelItem.getAttribute('todoListChecked');
+        const checkmarkElement = createCheckmarkElement(modelItem, viewWriter, isChecked, onCheckboxChecked);
+        const span = viewWriter.createContainerElement('span', {
+            class: 'todo-list__label__description'
+        });
+        viewWriter.addClass('todo-list', viewItem.parent);
+        viewWriter.insert(viewWriter.createPositionAt(viewItem, 0), checkmarkElement);
+        viewWriter.insert(viewWriter.createPositionAfter(checkmarkElement), span);
+        injectViewList(modelItem, viewItem, conversionApi, model);
+    };
+}
+/**
+ * A model-to-view converter for the `listItem` model element insertion.
+ *
+ * It is used by {@link module:engine/controller/datacontroller~DataController}.
+ *
+ * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:insert
+ * @param model Model instance.
+ * @returns Returns a conversion callback.
+ */
+export function dataModelViewInsertion(model) {
+    return (evt, data, conversionApi) => {
+        const consumable = conversionApi.consumable;
+        if (!consumable.test(data.item, 'insert') ||
+            !consumable.test(data.item, 'attribute:listType') ||
+            !consumable.test(data.item, 'attribute:listIndent')) {
+            return;
+        }
+        if (data.item.getAttribute('listType') != 'todo') {
+            return;
+        }
+        const modelItem = data.item;
+        consumable.consume(modelItem, 'insert');
+        consumable.consume(modelItem, 'attribute:listType');
+        consumable.consume(modelItem, 'attribute:listIndent');
+        consumable.consume(modelItem, 'attribute:todoListChecked');
+        const viewWriter = conversionApi.writer;
+        const viewItem = generateLiInUl(modelItem, conversionApi);
+        viewWriter.addClass('todo-list', viewItem.parent);
+        const label = viewWriter.createContainerElement('label', {
+            class: 'todo-list__label'
+        });
+        const checkbox = viewWriter.createEmptyElement('input', {
+            type: 'checkbox',
+            disabled: 'disabled'
+        });
+        const span = viewWriter.createContainerElement('span', {
+            class: 'todo-list__label__description'
+        });
+        if (modelItem.getAttribute('todoListChecked')) {
+            viewWriter.setAttribute('checked', 'checked', checkbox);
+        }
+        viewWriter.insert(viewWriter.createPositionAt(viewItem, 0), label);
+        viewWriter.insert(viewWriter.createPositionAt(label, 0), checkbox);
+        viewWriter.insert(viewWriter.createPositionAfter(checkbox), span);
+        injectViewList(modelItem, viewItem, conversionApi, model);
+    };
+}
+/**
+ * A view-to-model converter for the checkbox element inside a view list item.
+ *
+ * It changes the `listType` of the model `listItem` to a `todo` value.
+ * When a view checkbox element is marked as checked, an additional `todoListChecked="true"` attribute is added to the model item.
+ *
+ * It is used by {@link module:engine/controller/datacontroller~DataController}.
+ *
+ * @see module:engine/conversion/upcastdispatcher~UpcastDispatcher#event:element
+ */
+export const dataViewModelCheckmarkInsertion = (evt, data, conversionApi) => {
+    const modelCursor = data.modelCursor;
+    const modelItem = modelCursor.parent;
+    const viewItem = data.viewItem;
+    if (viewItem.getAttribute('type') != 'checkbox' || modelItem.name != 'listItem' || !modelCursor.isAtStart) {
+        return;
+    }
+    if (!conversionApi.consumable.consume(viewItem, { name: true })) {
+        return;
+    }
+    const writer = conversionApi.writer;
+    writer.setAttribute('listType', 'todo', modelItem);
+    if (data.viewItem.hasAttribute('checked')) {
+        writer.setAttribute('todoListChecked', true, modelItem);
+    }
+    data.modelRange = writer.createRange(modelCursor);
+};
+/**
+ * A model-to-view converter for the `listType` attribute change on the `listItem` model element.
+ *
+ * This change means that the `<li>` element parent changes to `<ul class="todo-list">` and a
+ * {@link module:engine/view/uielement~UIElement checkbox UI element} is added at the beginning
+ * of the list item element (or vice versa).
+ *
+ * This converter is preceded by {@link module:list/legacylist/legacyconverters~modelViewChangeType} and followed by
+ * {@link module:list/legacylist/legacyconverters~modelViewMergeAfterChangeType} to handle splitting and merging surrounding lists
+ * of the same type.
+ *
+ * It is used by {@link module:engine/controller/editingcontroller~EditingController}.
+ *
+ * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute
+ * @param onCheckedChange Callback fired after clicking the checkbox UI element.
+ * @param view Editing view controller.
+ * @returns Returns a conversion callback.
+ */
+export function modelViewChangeType(onCheckedChange, view) {
+    return (evt, data, conversionApi) => {
+        if (!conversionApi.consumable.consume(data.item, evt.name)) {
+            return;
+        }
+        const viewItem = conversionApi.mapper.toViewElement(data.item);
+        const viewWriter = conversionApi.writer;
+        const labelElement = findLabel(viewItem, view);
+        if (data.attributeNewValue == 'todo') {
+            const isChecked = !!data.item.getAttribute('todoListChecked');
+            const checkmarkElement = createCheckmarkElement(data.item, viewWriter, isChecked, onCheckedChange);
+            const span = viewWriter.createContainerElement('span', {
+                class: 'todo-list__label__description'
+            });
+            const itemRange = viewWriter.createRangeIn(viewItem);
+            const nestedList = findNestedList(viewItem);
+            const descriptionStart = positionAfterUiElements(itemRange.start);
+            const descriptionEnd = nestedList ? viewWriter.createPositionBefore(nestedList) : itemRange.end;
+            const descriptionRange = viewWriter.createRange(descriptionStart, descriptionEnd);
+            viewWriter.addClass('todo-list', viewItem.parent);
+            viewWriter.move(descriptionRange, viewWriter.createPositionAt(span, 0));
+            viewWriter.insert(viewWriter.createPositionAt(viewItem, 0), checkmarkElement);
+            viewWriter.insert(viewWriter.createPositionAfter(checkmarkElement), span);
+        }
+        else if (data.attributeOldValue == 'todo') {
+            const descriptionSpan = findDescription(viewItem, view);
+            viewWriter.removeClass('todo-list', viewItem.parent);
+            viewWriter.remove(labelElement);
+            viewWriter.move(viewWriter.createRangeIn(descriptionSpan), viewWriter.createPositionBefore(descriptionSpan));
+            viewWriter.remove(descriptionSpan);
+        }
+    };
+}
+/**
+ * A model-to-view converter for the `todoListChecked` attribute change on the `listItem` model element.
+ *
+ * It marks the {@link module:engine/view/uielement~UIElement checkbox UI element} as checked.
+ *
+ * It is used by {@link module:engine/controller/editingcontroller~EditingController}.
+ *
+ * @see module:engine/conversion/downcastdispatcher~DowncastDispatcher#event:attribute
+ * @param onCheckedChange Callback fired after clicking the checkbox UI element.
+ * @returns Returns a conversion callback.
+ */
+export function modelViewChangeChecked(onCheckedChange) {
+    return (evt, data, conversionApi) => {
+        // Do not convert `todoListChecked` attribute when to-do list item has changed to other list item.
+        // This attribute will be removed by the model post fixer.
+        if (data.item.getAttribute('listType') != 'todo') {
+            return;
+        }
+        if (!conversionApi.consumable.consume(data.item, 'attribute:todoListChecked')) {
+            return;
+        }
+        const { mapper, writer: viewWriter } = conversionApi;
+        const isChecked = !!data.item.getAttribute('todoListChecked');
+        const viewItem = mapper.toViewElement(data.item);
+        // Because of m -> v position mapper we can be sure checkbox is always at the beginning.
+        const oldCheckmarkElement = viewItem.getChild(0);
+        const newCheckmarkElement = createCheckmarkElement(data.item, viewWriter, isChecked, onCheckedChange);
+        viewWriter.insert(viewWriter.createPositionAfter(oldCheckmarkElement), newCheckmarkElement);
+        viewWriter.remove(oldCheckmarkElement);
+    };
+}
+/**
+ * A model-to-view position at zero offset mapper.
+ *
+ * This helper ensures that position inside todo-list in the view is mapped after the checkbox.
+ *
+ * It only handles the position at the beginning of a list item as other positions are properly mapped be the default mapper.
+ */
+export function mapModelToViewPosition(view) {
+    return (evt, data) => {
+        const modelPosition = data.modelPosition;
+        const parent = modelPosition.parent;
+        if (!parent.is('element', 'listItem') || parent.getAttribute('listType') != 'todo') {
+            return;
+        }
+        const viewLi = data.mapper.toViewElement(parent);
+        const descSpan = findDescription(viewLi, view);
+        if (descSpan) {
+            data.viewPosition = data.mapper.findPositionIn(descSpan, modelPosition.offset);
+        }
+    };
+}
+/**
+ * Creates a checkbox UI element.
+ */
+function createCheckmarkElement(modelItem, viewWriter, isChecked, onChange) {
+    const uiElement = viewWriter.createUIElement('label', {
+        class: 'todo-list__label',
+        contenteditable: false
+    }, function (domDocument) {
+        const checkbox = createElement(document, 'input', { type: 'checkbox', tabindex: '-1' });
+        if (isChecked) {
+            checkbox.setAttribute('checked', 'checked');
+        }
+        checkbox.addEventListener('change', () => onChange(modelItem));
+        const domElement = this.toDomElement(domDocument);
+        domElement.appendChild(checkbox);
+        return domElement;
+    });
+    return uiElement;
+}
+// Helper method to find label element inside li.
+function findLabel(viewItem, view) {
+    const range = view.createRangeIn(viewItem);
+    for (const value of range) {
+        if (value.item.is('uiElement', 'label')) {
+            return value.item;
+        }
+    }
+}
+function findDescription(viewItem, view) {
+    const range = view.createRangeIn(viewItem);
+    for (const value of range) {
+        if (value.item.is('containerElement', 'span') && value.item.hasClass('todo-list__label__description')) {
+            return value.item;
+        }
+    }
+}

package/src/legacytodolist/legacytodolistediting.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @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 LegacyListEditing from '../legacylist/legacylistediting.js';
+/**
+ * The engine of the to-do list feature. It handles creating, editing and removing to-do lists and their items.
+ *
+ * It registers the entire functionality of the {@link module:list/legacylist/legacylistediting~LegacyListEditing legacy list editing
+ * plugin} and extends it with the commands:
+ *
+ * - `'todoList'`,
+ * - `'checkTodoList'`,
+ * - `'todoListCheck'` as an alias for `checkTodoList` command.
+ */
+export default class LegacyTodoListEditing extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "LegacyTodoListEditing";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof LegacyListEditing];
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+    /**
+     * Handles the checkbox element change, moves the selection to the corresponding model item to make it possible
+     * to toggle the `todoListChecked` attribute using the command, and restores the selection position.
+     *
+     * Some say it's a hack :) Moving the selection only for executing the command on a certain node and restoring it after,
+     * is not a clear solution. We need to design an API for using commands beyond the selection range.
+     * See https://github.com/ckeditor/ckeditor5/issues/1954.
+     */
+    private _handleCheckmarkChange;
+    /**
+     * Observe when user enters or leaves todo list and set proper aria value in global live announcer.
+     * This allows screen readers to indicate when the user has entered and left the specified todo list.
+     *
+     * @internal
+     */
+    private _initAriaAnnouncements;
+}

package/src/legacytodolist/legacytodolistediting.js

@@ -0,0 +1,199 @@
+/**
+ * @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 { getCode, parseKeystroke, getLocalizedArrowKeyCodeDirection } from 'ckeditor5/src/utils.js';
+import LegacyListCommand from '../legacylist/legacylistcommand.js';
+import LegacyListEditing from '../legacylist/legacylistediting.js';
+import LegacyCheckTodoListCommand from './legacychecktodolistcommand.js';
+import { dataModelViewInsertion, dataViewModelCheckmarkInsertion, mapModelToViewPosition, modelViewChangeChecked, modelViewChangeType, modelViewInsertion } from './legacytodolistconverters.js';
+const ITEM_TOGGLE_KEYSTROKE = /* #__PURE__ */ parseKeystroke('Ctrl+Enter');
+/**
+ * The engine of the to-do list feature. It handles creating, editing and removing to-do lists and their items.
+ *
+ * It registers the entire functionality of the {@link module:list/legacylist/legacylistediting~LegacyListEditing legacy list editing
+ * plugin} and extends it with the commands:
+ *
+ * - `'todoList'`,
+ * - `'checkTodoList'`,
+ * - `'todoListCheck'` as an alias for `checkTodoList` command.
+ */
+export default class LegacyTodoListEditing extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'LegacyTodoListEditing';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [LegacyListEditing];
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        const { editing, data, model } = editor;
+        // Extend schema.
+        model.schema.extend('listItem', {
+            allowAttributes: ['todoListChecked']
+        });
+        // Disallow todoListChecked attribute on other nodes than listItem with to-do listType.
+        model.schema.addAttributeCheck((context, attributeName) => {
+            const item = context.last;
+            if (attributeName == 'todoListChecked' && item.name == 'listItem' && item.getAttribute('listType') != 'todo') {
+                return false;
+            }
+        });
+        // Register `todoList` command.
+        editor.commands.add('todoList', new LegacyListCommand(editor, 'todo'));
+        const checkTodoListCommand = new LegacyCheckTodoListCommand(editor);
+        // Register `checkTodoList` command and add `todoListCheck` command as an alias for backward compatibility.
+        editor.commands.add('checkTodoList', checkTodoListCommand);
+        editor.commands.add('todoListCheck', checkTodoListCommand);
+        // Define converters.
+        data.downcastDispatcher.on('insert:listItem', dataModelViewInsertion(model), { priority: 'high' });
+        data.upcastDispatcher.on('element:input', dataViewModelCheckmarkInsertion, { priority: 'high' });
+        editing.downcastDispatcher.on('insert:listItem', modelViewInsertion(model, listItem => this._handleCheckmarkChange(listItem)), { priority: 'high' });
+        editing.downcastDispatcher.on('attribute:listType:listItem', modelViewChangeType(listItem => this._handleCheckmarkChange(listItem), editing.view));
+        editing.downcastDispatcher.on('attribute:todoListChecked:listItem', modelViewChangeChecked(listItem => this._handleCheckmarkChange(listItem)));
+        editing.mapper.on('modelToViewPosition', mapModelToViewPosition(editing.view));
+        data.mapper.on('modelToViewPosition', mapModelToViewPosition(editing.view));
+        // Jump at the end of the previous node on left arrow key press, when selection is after the checkbox.
+        //
+        // <blockquote><p>Foo</p></blockquote>
+        // <ul><li><checkbox/>{}Bar</li></ul>
+        //
+        // press: `<-`
+        //
+        // <blockquote><p>Foo{}</p></blockquote>
+        // <ul><li><checkbox/>Bar</li></ul>
+        //
+        this.listenTo(editing.view.document, 'arrowKey', jumpOverCheckmarkOnSideArrowKeyPress(model, editor.locale), { context: 'li' });
+        // Toggle check state of selected to-do list items on keystroke.
+        this.listenTo(editing.view.document, 'keydown', (evt, data) => {
+            if (getCode(data) === ITEM_TOGGLE_KEYSTROKE) {
+                editor.execute('checkTodoList');
+                evt.stop();
+            }
+        }, { priority: 'high' });
+        // Remove `todoListChecked` attribute when a host element is no longer a to-do list item.
+        const listItemsToFix = new Set();
+        this.listenTo(model, 'applyOperation', (evt, args) => {
+            const operation = args[0];
+            if (operation.type == 'rename' && operation.oldName == 'listItem') {
+                const item = operation.position.nodeAfter;
+                if (item.hasAttribute('todoListChecked')) {
+                    listItemsToFix.add(item);
+                }
+            }
+            else if (operation.type == 'changeAttribute' && operation.key == 'listType' && operation.oldValue === 'todo') {
+                for (const item of operation.range.getItems()) {
+                    if (item.hasAttribute('todoListChecked') && item.getAttribute('listType') !== 'todo') {
+                        listItemsToFix.add(item);
+                    }
+                }
+            }
+        });
+        model.document.registerPostFixer(writer => {
+            let hasChanged = false;
+            for (const listItem of listItemsToFix) {
+                writer.removeAttribute('todoListChecked', listItem);
+                hasChanged = true;
+            }
+            listItemsToFix.clear();
+            return hasChanged;
+        });
+        this._initAriaAnnouncements();
+    }
+    /**
+     * Handles the checkbox element change, moves the selection to the corresponding model item to make it possible
+     * to toggle the `todoListChecked` attribute using the command, and restores the selection position.
+     *
+     * Some say it's a hack :) Moving the selection only for executing the command on a certain node and restoring it after,
+     * is not a clear solution. We need to design an API for using commands beyond the selection range.
+     * See https://github.com/ckeditor/ckeditor5/issues/1954.
+     */
+    _handleCheckmarkChange(listItem) {
+        const editor = this.editor;
+        const model = editor.model;
+        const previousSelectionRanges = Array.from(model.document.selection.getRanges());
+        model.change(writer => {
+            writer.setSelection(listItem, 'end');
+            editor.execute('checkTodoList');
+            writer.setSelection(previousSelectionRanges);
+        });
+    }
+    /**
+     * Observe when user enters or leaves todo list and set proper aria value in global live announcer.
+     * This allows screen readers to indicate when the user has entered and left the specified todo list.
+     *
+     * @internal
+     */
+    _initAriaAnnouncements() {
+        const { model, ui, t } = this.editor;
+        let lastFocusedCodeBlock = null;
+        if (!ui) {
+            return;
+        }
+        model.document.selection.on('change:range', () => {
+            const focusParent = model.document.selection.focus.parent;
+            const lastElementIsTodoList = isLegacyTodoListItemElement(lastFocusedCodeBlock);
+            const currentElementIsTodoList = isLegacyTodoListItemElement(focusParent);
+            if (lastElementIsTodoList && !currentElementIsTodoList) {
+                ui.ariaLiveAnnouncer.announce(t('Leaving a to-do list'));
+            }
+            else if (!lastElementIsTodoList && currentElementIsTodoList) {
+                ui.ariaLiveAnnouncer.announce(t('Entering a to-do list'));
+            }
+            lastFocusedCodeBlock = focusParent;
+        });
+    }
+}
+/**
+ * Handles the left/right (LTR/RTL content) arrow key and moves the selection at the end of the previous block element
+ * if the selection is just after the checkbox element. In other words, it jumps over the checkbox element when
+ * moving the selection to the left/right (LTR/RTL).
+ *
+ * @returns Callback for 'keydown' events.
+ */
+function jumpOverCheckmarkOnSideArrowKeyPress(model, locale) {
+    return (eventInfo, domEventData) => {
+        const direction = getLocalizedArrowKeyCodeDirection(domEventData.keyCode, locale.contentLanguageDirection);
+        if (direction != 'left') {
+            return;
+        }
+        const schema = model.schema;
+        const selection = model.document.selection;
+        if (!selection.isCollapsed) {
+            return;
+        }
+        const position = selection.getFirstPosition();
+        const parent = position.parent;
+        if (parent.name === 'listItem' && parent.getAttribute('listType') == 'todo' && position.isAtStart) {
+            const newRange = schema.getNearestSelectionRange(model.createPositionBefore(parent), 'backward');
+            if (newRange) {
+                model.change(writer => writer.setSelection(newRange));
+            }
+            domEventData.preventDefault();
+            domEventData.stopPropagation();
+            eventInfo.stop();
+        }
+    };
+}
+/**
+ * Returns true if the given element is a list item model element of a to-do list.
+ */
+function isLegacyTodoListItemElement(element) {
+    return !!element && element.is('element', 'listItem') && element.getAttribute('listType') === 'todo';
+}

package/src/legacytodolist.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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/legacytodolist
+ */
+import LegacyTodoListEditing from './legacytodolist/legacytodolistediting.js';
+import TodoListUI from './todolist/todolistui.js';
+import { Plugin } from 'ckeditor5/src/core.js';
+import '../theme/todolist.css';
+/**
+ * The legacy to-do list feature.
+ *
+ * This is a "glue" plugin that loads the {@link module:list/legacytodolist/legacytodolistediting~LegacyTodoListEditing legacy to-do list
+ * editing feature} and the {@link module:list/todolist/todolistui~TodoListUI to-do list UI feature}.
+ */
+export default class LegacyTodoList extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof LegacyTodoListEditing, typeof TodoListUI];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "LegacyTodoList";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+}

package/src/legacytodolist.js

@@ -0,0 +1,37 @@
+/**
+ * @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/legacytodolist
+ */
+import LegacyTodoListEditing from './legacytodolist/legacytodolistediting.js';
+import TodoListUI from './todolist/todolistui.js';
+import { Plugin } from 'ckeditor5/src/core.js';
+import '../theme/todolist.css';
+/**
+ * The legacy to-do list feature.
+ *
+ * This is a "glue" plugin that loads the {@link module:list/legacytodolist/legacytodolistediting~LegacyTodoListEditing legacy to-do list
+ * editing feature} and the {@link module:list/todolist/todolistui~TodoListUI to-do list UI feature}.
+ */
+export default class LegacyTodoList extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [LegacyTodoListEditing, TodoListUI];
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'LegacyTodoList';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+}

package/src/list/adjacentlistssupport.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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';
+export default class AdjacentListsSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "AdjacentListsSupport";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+}