@ckeditor/ckeditor5-paste-from-office 48.0.1-alpha.1 → 48.1.0-alpha.0

package/dist/filters/bookmark.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module paste-from-office/filters/bookmark
  */
-import { type ViewUpcastWriter, type ViewDocumentFragment } from '@ckeditor/ckeditor5-engine';
+import type { ViewUpcastWriter, ViewDocumentFragment } from '@ckeditor/ckeditor5-engine';
 /**
  * Transforms `<a>` elements which are bookmarks by moving their children after the element.
  *

package/dist/index.js

@@ -27,8 +27,25 @@ import { ViewUpcastWriter, Matcher, ViewDocument, ViewDomConverter } from '@cked
         const index = element.parent.getChildIndex(element) + 1;
         const children = element.getChildren();
         writer.insertChild(index, children, element.parent);
+        if (isHiddenBookmarkAnchor(element)) {
+            writer.remove(element);
+        }
     }
 }
+/**
+ * Checks whether the given element is a hidden or auto-generated bookmark anchor.
+ *
+ * Editors like MS Word and Google Docs use the `name` attribute (rather than `id`)
+ * for bookmarks. Furthermore, they reserve `_`-prefixed bookmark names for
+ * auto-generated anchors (e.g., Table of Contents or internal hyperlinks) and
+ * do not allow users to manually create custom bookmarks starting with an underscore.
+ *
+ * @param element The element to check.
+ * @returns True if the element is a hidden bookmark anchor, false otherwise.
+ */ function isHiddenBookmarkAnchor(element) {
+    const name = element.getAttribute('name');
+    return !!name && name.startsWith('_');
+}
 
 /**
  * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -96,7 +113,13 @@ import { ViewUpcastWriter, Matcher, ViewDocument, ViewDomConverter } from '@cked
     if (!itemLikeElements.length) {
         return;
     }
-    const encounteredLists = {};
+    // Tracks how many items have been added to each encountered list, keyed by indent level and list ID.
+    // Used to set the `start` attribute on a new <ol> when a list at a given indent is interrupted by
+    // a non-list block (e.g. a paragraph) and then resumed.
+    // Structure: [ { [listId:level]: itemCount } ] (array index is the indent level)
+    // Example: [ { '1:1': 3 }, { '0:2': 2 } ] means the top-level list (id=1) has 3 items,
+    // and the nested list (id=0) has 2 items so the next continuation should start at 3.
+    const encounteredLists = [];
     const stack = [];
     let topLevelListInfo = createTopLevelListInfo();
     for (const itemLikeElement of itemLikeElements){
@@ -104,26 +127,40 @@ import { ViewUpcastWriter, Matcher, ViewDocument, ViewDomConverter } from '@cked
             if (!isListContinuation(itemLikeElement)) {
                 applyIndentationToTopLevelList(writer, stack, topLevelListInfo);
                 topLevelListInfo = createTopLevelListInfo();
+                // Clear counters for nested levels only. The top-level counter (index 0) must survive
+                // so that a resumed top-level list (same id, interrupted by a paragraph) can still
+                // receive the correct `start` attribute. Nested counters must be cleared because
+                // a sibling top-level list item should not inherit the nested list counts from
+                // a previous top-level list item.
+                encounteredLists.length = 1;
                 stack.length = 0;
             }
-            // Combined list ID for addressing encounter lists counters.
+            // Key used to look up this list inside `encounteredLists[indent]`.
+            // Combines the list id and level so that two different lists at the same indent
+            // level (e.g. first an <ol>, then a <ul> after a paragraph break) don't share a counter.
             const originalListId = `${itemLikeElement.id}:${itemLikeElement.indent}`;
             // Normalized list item indentation.
             const indent = Math.min(itemLikeElement.indent - 1, stack.length);
             // Trimming of the list stack on list ID change.
             if (indent < stack.length && stack[indent].id !== itemLikeElement.id) {
+                // A different list started at this indent level — counters for this level and deeper
+                // belong to the previous list context and must not carry over.
+                encounteredLists.length = indent;
                 stack.length = indent;
             }
             // Trimming of the list stack on lower indent list encountered.
             if (indent < stack.length - 1) {
+                // We jumped back to a shallower indent — any counters deeper than the new top are stale.
+                encounteredLists.length = indent + 1;
                 stack.length = indent + 1;
             } else {
                 const listStyle = detectListStyle(itemLikeElement, stylesString);
                 // Create a new OL/UL if required (greater indent or different list type).
                 if (indent > stack.length - 1 || stack[indent].listElement.name != listStyle.type) {
-                    // Check if there is some start index to set from a previous list.
-                    if (indent == 0 && listStyle.type == 'ol' && itemLikeElement.id !== undefined && encounteredLists[originalListId]) {
-                        listStyle.startIndex = encounteredLists[originalListId];
+                    // If this list was seen before at this indent (i.e. it was interrupted by a non-list block
+                    // and is now resuming), set `start` so the numbering continues from where it left off.
+                    if (listStyle.type == 'ol' && itemLikeElement.id !== undefined && encounteredLists[indent] && encounteredLists[indent][originalListId]) {
+                        listStyle.startIndex = encounteredLists[indent][originalListId];
                     }
                     const listElement = createNewEmptyList(listStyle, writer, hasMultiLevelListPlugin);
                     // Insert the new OL/UL.
@@ -141,9 +178,14 @@ import { ViewUpcastWriter, Matcher, ViewDocument, ViewDomConverter } from '@cked
                         listElement,
                         listItemElements: []
                     };
-                    // Prepare list counter for start index.
-                    if (indent == 0 && itemLikeElement.id !== undefined) {
-                        encounteredLists[originalListId] = listStyle.startIndex || 1;
+                    // Record the starting value for this list so that if it is interrupted and resumed later,
+                    // the continuation list can pick up numbering from the right value.
+                    // For a fresh list `listStyle.startIndex` is undefined, so we fall back to 1.
+                    if (itemLikeElement.id !== undefined) {
+                        if (!encounteredLists[indent]) {
+                            encounteredLists[indent] = {};
+                        }
+                        encounteredLists[indent][originalListId] = listStyle.startIndex || 1;
                     }
                 }
             }
@@ -154,9 +196,9 @@ import { ViewUpcastWriter, Matcher, ViewDocument, ViewDomConverter } from '@cked
             // Append the LI to OL/UL.
             writer.appendChild(listItem, stack[indent].listElement);
             stack[indent].listItemElements.push(listItem);
-            // Increment list counter.
-            if (indent == 0 && itemLikeElement.id !== undefined) {
-                encounteredLists[originalListId]++;
+            // Count the item so that `encounteredLists` always holds the value the *next* continuation list should start at.
+            if (itemLikeElement.id !== undefined && encounteredLists[indent]) {
+                encounteredLists[indent][originalListId]++;
             }
             // Append list block to LI.
             if (itemLikeElement.element != listItem) {
@@ -169,12 +211,22 @@ import { ViewUpcastWriter, Matcher, ViewDocument, ViewDomConverter } from '@cked
         } else {
             // Other blocks in a list item.
             const stackItem = stack.find((stackItem)=>stackItem.marginLeft == itemLikeElement.marginLeft);
-            // This might be a paragraph that has known margin, but it is not a real list block.
+            // A non-list block (e.g. a plain paragraph) whose margin-left matches one of the active list items.
+            // The match is done by margin-left value — nested list items sometimes have no explicit margin-left,
+            // so the match typically resolves to an ancestor <li> rather than the deepest one.
             if (stackItem) {
                 const listItems = stackItem.listItemElements;
                 // Append block to LI.
                 writer.appendChild(itemLikeElement.element, listItems[listItems.length - 1]);
                 writer.removeStyle('margin-left', itemLikeElement.element);
+                // Trim the stack to the matched level. Without this, the next nested list item would
+                // be appended to the existing nested <ol>/<ul> that appears *before* this paragraph
+                // in the DOM, instead of creating a new one *after* it.
+                stack.length = stack.indexOf(stackItem) + 1;
+                // Clear counters only for levels deeper than the direct children of the matched <li>.
+                // The counter at `stack.length` must survive so the next nested list can continue
+                // numbering from where it left off (e.g. <ol start="3">).
+                encounteredLists.length = stack.length + 1;
             } else {
                 stack.length = 0;
             }