@ckeditor/ckeditor5-list 0.0.0-internal-20241017.0

package/src/legacylist/legacylistediting.js

@@ -0,0 +1,167 @@
+/**
+ * @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 isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @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,45 @@
+/**
+ * @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";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * 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,52 @@
+/**
+ * @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';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * 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);
+    }
+}

package/src/legacylist/legacyutils.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @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/legacyutils
+ */
+import { type DowncastConversionApi, type DowncastWriter, type Element, type Item, type Model, type Position, type ViewContainerElement, type ViewElement, type ViewItem, type ViewPosition } from 'ckeditor5/src/engine.js';
+/**
+ * Creates a list item {@link module:engine/view/containerelement~ContainerElement}.
+ *
+ * @param writer The writer instance.
+ */
+export declare function createViewListItemElement(writer: DowncastWriter): ViewContainerElement;
+/**
+ * Helper function that creates a `<ul><li></li></ul>` or (`<ol>`) structure out of the given `modelItem` model `listItem` element.
+ * Then, it binds the created view list item (`<li>`) with the model `listItem` element.
+ * The function then returns the created view list item (`<li>`).
+ *
+ * @param modelItem Model list item.
+ * @param conversionApi Conversion interface.
+ * @returns View list element.
+ */
+export declare function generateLiInUl(modelItem: Item, conversionApi: DowncastConversionApi): ViewContainerElement;
+/**
+ * Helper function that inserts a view list at a correct place and merges it with its siblings.
+ * It takes a model list item element (`modelItem`) and a corresponding view list item element (`injectedItem`). The view list item
+ * should be in a view list element (`<ul>` or `<ol>`) and should be its only child.
+ * See comments below to better understand the algorithm.
+ *
+ * @param modelItem Model list item.
+ * @param injectedItem
+ * @param conversionApi Conversion interface.
+ * @param model The model instance.
+ */
+export declare function injectViewList(modelItem: Element, injectedItem: ViewContainerElement, conversionApi: DowncastConversionApi, model: Model): void;
+/**
+ * Helper function that takes two parameters that are expected to be view list elements, and merges them.
+ * The merge happens only if both parameters are list elements of the same type (the same element name and the same class attributes).
+ *
+ * @param viewWriter The writer instance.
+ * @param firstList The first element to compare.
+ * @param secondList The second element to compare.
+ * @returns The position after merge or `null` when there was no merge.
+ */
+export declare function mergeViewLists(viewWriter: DowncastWriter, firstList: ViewItem, secondList: ViewItem): ViewPosition | null;
+/**
+ * Helper function that for a given `view.Position`, returns a `view.Position` that is after all `view.UIElement`s that
+ * are after the given position.
+ *
+ * For example:
+ * `<container:p>foo^<ui:span></ui:span><ui:span></ui:span>bar</container:p>`
+ * For position ^, the position before "bar" will be returned.
+ *
+ */
+export declare function positionAfterUiElements(viewPosition: ViewPosition): ViewPosition;
+/**
+ * Helper function that searches for a previous list item sibling of a given model item that meets the given criteria
+ * passed by the options object.
+ *
+ * @param options Search criteria.
+ * @param options.sameIndent Whether the sought sibling should have the same indentation.
+ * @param options.smallerIndent Whether the sought sibling should have a smaller indentation.
+ * @param options.listIndent The reference indentation.
+ * @param options.direction Walking direction.
+ */
+export declare function getSiblingListItem(modelItem: Item | null, options: {
+    sameIndent?: boolean;
+    smallerIndent?: boolean;
+    listIndent?: number;
+    direction?: 'forward' | 'backward';
+}): Element | null;
+/**
+ * Returns a first list view element that is direct child of the given view element.
+ */
+export declare function findNestedList(viewElement: ViewElement): ViewElement | null;
+/**
+ * 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.
+ */
+export declare function getSiblingNodes(position: Position, direction: 'forward' | 'backward'): Array<Element>;
+/**
+ * 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.
+ *
+ * @internal
+ */
+export declare function getSelectedListItems(model: Model): Array<Element>;
+/**
+ * Checks whether the given list-style-type is supported by numbered or bulleted list.
+ */
+export declare function getListTypeFromListStyleType(listStyleType: string): 'bulleted' | 'numbered' | null;