@heartlandone/vega 2.94.0 → 2.96.0

package/dist/collection/components/vega-modal/slimmers/renderers/vega-modal-renderer.js

@@ -28,12 +28,13 @@ export class VegaModalRenderer extends VegaSlimmer {
     return this.modalContainer;
   }
   render() {
+    const effectiveWidth = this.sizeDeprecatedPropertySlimmer.getValue();
     return (h(Host, { class: {
         'align-center': this.deprecatedPropertySlimmer.getValue() && this.openState.isOpen,
         'animation': this.animation,
         'is-section-padding': isVegaModalSectionPaddingType(this.padding),
       } },
-      h("vega-box", { class: "modal-dialog", role: "dialog", "aria-modal": "true", "aria-labelledby": this.titleId, width: isResponsiveSizeType(this.size) ? this.size : DefaultModalSize, height: this.height, margin: this.margin }, this.renderContainer())));
+      h("vega-box", { class: "modal-dialog", role: "dialog", "aria-modal": "true", "aria-labelledby": this.titleId, width: isResponsiveSizeType(effectiveWidth) ? effectiveWidth : DefaultModalSize, height: this.height, margin: this.margin }, this.renderContainer())));
   }
   renderContainer() {
     return (h("vega-box", { class: "modal-container", corners: this.corners, ref: (node) => (this.modalContainer = node) },
@@ -113,7 +114,7 @@ __decorate([
 ], VegaModalRenderer.prototype, "margin", void 0);
 __decorate([
   MapToComponentField()
-], VegaModalRenderer.prototype, "size", void 0);
+], VegaModalRenderer.prototype, "sizeDeprecatedPropertySlimmer", void 0);
 __decorate([
   MapToComponentField()
 ], VegaModalRenderer.prototype, "height", void 0);

package/dist/collection/components/vega-modal/vega-modal.js

@@ -20,7 +20,7 @@ import { VegaModalRenderer } from './slimmers/renderers/vega-modal-renderer';
 import { VegaModalMobileController } from './slimmers/controllers/vega-modal-mobile-controller';
 import { VegaModalScrollController } from './slimmers/controllers/vega-modal-scroll-controller';
 import { VegaModalOpenStateController } from './slimmers/controllers/vega-modal-open-state-controller';
-import { VegaModalBackdropController } from './slimmers/controllers/vega-modal-backdrop-controller';
+import { VegaModalBackdropManager } from './slimmers/controllers/vega-modal-backdrop-manager';
 import { VegaModalOpenedModalStackController } from './slimmers/controllers/vega-modal-opened-modal-stack-controller';
 import { VegaModalZIndexController } from './slimmers/controllers/vega-modal-z-index-controller';
 import { VegaModalOpenState } from './slimmers/models/vega-modal-open-state';
@@ -35,7 +35,7 @@ export class VegaModal {
     this.openStateController = new VegaModalOpenStateController();
     this.mobileController = new VegaModalMobileController();
     this.scrollController = new VegaModalScrollController();
-    this.backdropController = new VegaModalBackdropController();
+    this.backdropManager = new VegaModalBackdropManager();
     this.openedModalStackController = new VegaModalOpenedModalStackController();
     this.zIndexController = new VegaModalZIndexController();
     this.paddingStateController = new VegaModalPaddingStateController();
@@ -45,6 +45,7 @@ export class VegaModal {
     this.childNodesEventPrevent = new ChildNodesEventPreventSlimmer([VegaOpen, VegaClose], () => this.renderer.getModalContainerRef());
     this.componentGlobalStyleSlimmer = new ComponentGlobalStyleSlimmer(mainContentStyle);
     this.deprecatedPropertySlimmer = createDeprecatedPropertySlimmer(VegaModal, 'isVerticallyCentered', 'isVerticallyCenter', false);
+    this.sizeDeprecatedPropertySlimmer = createDeprecatedPropertySlimmer(VegaModal, 'width', 'size', undefined);
     this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer(VegaModalRuntimeMetricsPayloadDefinition);
     this.openState = this.initOpenState();
     /**
@@ -58,10 +59,6 @@ export class VegaModal {
      * - `none`:
      *      specifies that the backdrop will not be rendered.
      *
-     * _Note_:
-     *    When changing this value, a page refresh is required
-     *    for the changes to take effect.
-     *
      * @vegaVersion 1.0.6
      */
     this.backdrop = 'default';
@@ -153,6 +150,13 @@ export class VegaModal {
   watchOpenState() {
     methodPlaceholder();
   }
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-modal-default-e2e}
+   */
+  watchBackdrop() {
+    methodPlaceholder();
+  }
   /**
    * The below method is e2e-test covered in
    * @see{module:vega-modal-size-number-e2e}
@@ -162,6 +166,15 @@ export class VegaModal {
   watchSize() {
     methodPlaceholder();
   }
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-modal-width-number-e2e}
+   * @see{module:vega-modal-width-responsive-e2e}
+   */
+  /* istanbul ignore next */
+  watchWidth() {
+    methodPlaceholder();
+  }
   /**
    * The below method is e2e-test covered in
    * @see{module:vega-modal-height-e2e}
@@ -173,6 +186,15 @@ export class VegaModal {
   watchOpen() {
     this.openState = new VegaModalOpenState(this.open, 'property');
   }
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-modal-backdrop-color-default-e2e}
+   * @see{module:vega-modal-backdrop-color-semi-e2e}
+   * @see{module:vega-modal-backdrop-color-none-e2e}
+   */
+  watchBackdropColor() {
+    methodPlaceholder();
+  }
   watchPadding() {
     methodPlaceholder();
   }
@@ -226,6 +248,9 @@ export class VegaModal {
   async modal(option) {
     methodPlaceholder(option);
   }
+  /* The disconnectedCallback lifecycle is e2e-test covered in
+   * @see{module:vega-modal-disconnected-callback-e2e}
+   */
   render() {
     return sanitizeVegaComponent(this.renderer.render(), this.host);
   }
@@ -264,7 +289,7 @@ export class VegaModal {
             "name": "vegaVersion",
             "text": "1.0.6"
           }],
-        "text": "Provides options for controlling the behavior of the backdrop.\n- `default`:\n     indicates that the user can close the modal\n     by clicking on the backdrop.\n- `static`:\n     means that the user cannot close the modal by\n     clicking on the backdrop.\n- `none`:\n     specifies that the backdrop will not be rendered.\n\n_Note_:\n   When changing this value, a page refresh is required\n   for the changes to take effect."
+        "text": "Provides options for controlling the behavior of the backdrop.\n- `default`:\n     indicates that the user can close the modal\n     by clicking on the backdrop.\n- `static`:\n     means that the user cannot close the modal by\n     clicking on the backdrop.\n- `none`:\n     specifies that the backdrop will not be rendered."
       },
       "attribute": "backdrop",
       "reflect": false,
@@ -291,6 +316,9 @@ export class VegaModal {
       "optional": false,
       "docs": {
         "tags": [{
+            "name": "deprecated",
+            "text": "This property will be removed soon and replaced by prop width"
+          }, {
             "name": "vegaVersion",
             "text": "1.0.6"
           }],
@@ -299,6 +327,35 @@ export class VegaModal {
       "attribute": "size",
       "reflect": false
     },
+    "width": {
+      "type": "any",
+      "mutable": false,
+      "complexType": {
+        "original": "ResponsiveType<SizeType>",
+        "resolved": "`${number}%` | number | { S?: SizeType; M?: SizeType; L?: SizeType; XL?: SizeType; default?: SizeType; }",
+        "references": {
+          "ResponsiveType": {
+            "location": "import",
+            "path": "../../types/ui.type"
+          },
+          "SizeType": {
+            "location": "import",
+            "path": "../../types/ui.type"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [{
+            "name": "vegaVersion",
+            "text": "2.95.0"
+          }],
+        "text": "Determines the width of the modal.\n\nIt can be specified as a number or a percentage string ending with \"%\".\nResponsiveType can also be used for responsive configurations.\n\nNote: There are different maximum widths for modal windows based on viewport size.\nIf the specified width exceeds the maximum width, the maximum modal width will be used instead."
+      },
+      "attribute": "width",
+      "reflect": false
+    },
     "height": {
       "type": "any",
       "mutable": false,
@@ -730,15 +787,24 @@ export class VegaModal {
   static get watchers() { return [{
       "propName": "openState",
       "methodName": "watchOpenState"
+    }, {
+      "propName": "backdrop",
+      "methodName": "watchBackdrop"
     }, {
       "propName": "size",
       "methodName": "watchSize"
+    }, {
+      "propName": "width",
+      "methodName": "watchWidth"
     }, {
       "propName": "height",
       "methodName": "watchHeight"
     }, {
       "propName": "open",
       "methodName": "watchOpen"
+    }, {
+      "propName": "backdropColor",
+      "methodName": "watchBackdropColor"
     }, {
       "propName": "padding",
       "methodName": "watchPadding"
@@ -789,7 +855,7 @@ __decorate([
 ], VegaModal.prototype, "scrollController", void 0);
 __decorate([
   InjectVegaSlimmer()
-], VegaModal.prototype, "backdropController", void 0);
+], VegaModal.prototype, "backdropManager", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], VegaModal.prototype, "openedModalStackController", void 0);
@@ -817,6 +883,9 @@ __decorate([
 __decorate([
   InjectVegaSlimmer()
 ], VegaModal.prototype, "deprecatedPropertySlimmer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaModal.prototype, "sizeDeprecatedPropertySlimmer", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], VegaModal.prototype, "vegaComponentUsageRuntimeMetricsSlimmer", void 0);

package/dist/collection/components/vega-progress-tracker/slimmers/controllers/vega-progress-tracker-current-steps-controller.js

@@ -59,6 +59,10 @@ export class VegaProgressTrackerCurrentStepsController extends VegaSlimmer {
   watchCompletedSteps() {
     this.syncUpCurrentSteps();
   }
+  /** while canClickStep changed, we need sync up current steps */
+  watchCanClickStep() {
+    this.syncUpCurrentSteps();
+  }
   /**
    * Sync up current steps
    */
@@ -123,3 +127,6 @@ __decorate([
 __decorate([
   MapToComponentMethod('watchCompletedSteps')
 ], VegaProgressTrackerCurrentStepsController.prototype, "watchCompletedSteps", null);
+__decorate([
+  MapToComponentMethod('watchCanClickStep')
+], VegaProgressTrackerCurrentStepsController.prototype, "watchCanClickStep", null);

package/dist/collection/components/vega-progress-tracker/vega-progress-tracker.js

@@ -130,6 +130,9 @@ export class VegaProgressTracker {
   watchCompletedSteps() {
     methodPlaceholder();
   }
+  watchCanClickStep() {
+    methodPlaceholder();
+  }
   /**
    * Invoke this method to change the tracker's current step
    *    to the next step, if available.
@@ -486,6 +489,9 @@ export class VegaProgressTracker {
     }, {
       "propName": "completedSteps",
       "methodName": "watchCompletedSteps"
+    }, {
+      "propName": "canClickStep",
+      "methodName": "watchCanClickStep"
     }]; }
 }
 __decorate([

package/dist/collection/components/vega-rich-text-content/vega-rich-text-content.css

@@ -111,6 +111,10 @@
   padding-left: 8px;
   margin-left: 16px;
 }
+:host .rich-text-content ul.v-rte--list > li::marker,
+:host .rich-text-content ol.v-rte--list > li::marker {
+  font-size: 16px;
+}
 :host .rich-text-content .link-editor-wrapper {
   position: relative;
   outline: 2px solid transparent;

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-delete-node-content-strategy.js

@@ -1,3 +1,4 @@
+import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
 /**
  * The delete node content contains some common functions that used for image block delete the image node or text block delete text node.
@@ -10,12 +11,29 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @returns {Nullable<RTENode>} the previous block last node
    */
   getPreviousNode(currentNode) {
+    var _a;
     const currentBlock = currentNode.parent;
     const currentIndex = currentBlock.children.indexOf(currentNode);
     if (currentIndex > 0) {
       return currentBlock.children[currentIndex - 1];
     }
     else if (currentBlock.parent) {
+      // Special case: cursor is at the start of the first item in a nested list.
+      // Return the last direct text node of the grandparent list item so that
+      // Backspace correctly merges the nested item into the parent item rather
+      // than descending into the nested list's own descendants.
+      if (currentBlock.isListItemBlock() &&
+        currentBlock.parent.children.indexOf(currentBlock) === 0 &&
+        currentBlock.parent.parent instanceof RTEListItemBlock) {
+        const grandParentItem = currentBlock.parent.parent;
+        const nestedListIndex = ((_a = grandParentItem.nestList) !== null && _a !== void 0 ? _a : []).indexOf(currentBlock.parent);
+        if (nestedListIndex !== 0) {
+          const previousBlock = this.getPreviousBlock(currentBlock);
+          return previousBlock ? this.getBlockLastNode(previousBlock) : null;
+        }
+        const textNodes = grandParentItem.children;
+        return textNodes.length > 0 ? textNodes[textNodes.length - 1] : null;
+      }
       const previousBlock = this.getPreviousBlock(currentBlock);
       if (previousBlock) {
         return this.getBlockLastNode(previousBlock);
@@ -72,6 +90,17 @@ export class BlockDeleteNodeContentStrategy extends ActionHandleStrategy {
    * @returns {Nullable<RTEBlock>} The previous block if existing
    */
   getPreviousBlock(currentBlock) {
+    var _a;
+    if (currentBlock.parent instanceof RTEListItemBlock) {
+      const nestedLists = (_a = currentBlock.parent.nestList) !== null && _a !== void 0 ? _a : [];
+      const nestedListIndex = nestedLists.indexOf(currentBlock);
+      if (nestedListIndex > 0) {
+        return nestedLists[nestedListIndex - 1];
+      }
+      if (nestedListIndex === 0) {
+        return currentBlock.parent;
+      }
+    }
     if (currentBlock && currentBlock.parent && currentBlock.parent.children) {
       const currentBlockIndex = currentBlock.parent.children.indexOf(currentBlock);
       if (currentBlockIndex > 0) {

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-delete-text-or-decorator-node-strategy.js

@@ -40,6 +40,8 @@ export class BlockDeleteTextOrDecoratorNodeStrategy extends BlockDeleteNodeConte
         return;
       }
       else {
+        const nodeIndex = target.children.indexOf(startContainerNode);
+        const nextSiblingNode = target.children[nodeIndex + 1];
         const previousNode = this.getPreviousNode(startContainerNode);
         // Remove the last character will not delete paragraph, the paragraph will removed after press delete again
         if ((previousNode && previousNode.parent === target && previousNode['text'] === '\n') ||
@@ -49,7 +51,14 @@ export class BlockDeleteTextOrDecoratorNodeStrategy extends BlockDeleteNodeConte
         }
         else {
           target.apply(new RemoveChildrenAction(startContainerNode));
-          action.previousNode = previousNode;
+          // If this was the first node, the previous node may belong to an ancestor list
+          // item. Keep the caret at the deletion boundary before the surviving sibling.
+          if (nextSiblingNode && (previousNode === null || previousNode === void 0 ? void 0 : previousNode.parent) !== target) {
+            action.nextNode = nextSiblingNode;
+          }
+          else {
+            action.previousNode = previousNode;
+          }
           return;
         }
       }

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-transform-to-list-strategy.js

@@ -2,6 +2,7 @@ import { AppendChildrenAction } from '../../actions/append-child-nodes-action';
 import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
 import { RemoveChildrenAction } from '../../actions/remove-child-action';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { normalizeMixedListSelection } from './list-transform-selection';
 /**
  * Convert the selected blocks to list strategy.
  */
@@ -13,12 +14,16 @@ export class BlockTransformToListStrategy extends ActionHandleStrategy {
    * @param {RTETextBlock} target - The first item of the selected block.
    */
   handleAction(action, target) {
-    const contentState = target.parent;
+    const contentState = this.getRootContent(target);
+    if (!contentState) {
+      return;
+    }
+    const container = target.parent;
     const bulletList = contentState.createList(action.listType);
-    const selectedBlocks = action.selectedBlocks;
+    const selectedBlocks = normalizeMixedListSelection(action.selectedBlocks, action.listType);
     const listItems = selectedBlocks.map((block) => contentState.toListItem(block));
     bulletList.apply(new AppendChildrenAction(listItems));
-    contentState.apply(new InsertChildrenAfterAction(action.selectedBlocks[0], bulletList));
+    container.apply(new InsertChildrenAfterAction(action.selectedBlocks[0], bulletList));
     selectedBlocks.forEach((block) => {
       block.parent.apply(new RemoveChildrenAction(block));
     });

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-annotation-strategy.abstract.js

@@ -0,0 +1,60 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Base strategy for list operations that reconstruct or merge list containers.
+ * Keeps annotation cloning and equality rules consistent across those operations.
+ */
+export class ListAnnotationStrategy extends ActionHandleStrategy {
+  /**
+   * Copy list-container annotations without sharing mutable annotation instances.
+   * Factory-provided defaults remain intact unless the source supplies the same key.
+   *
+   * @param {RTEListBlock} source - List whose annotations should be copied.
+   * @param {RTEListBlock} target - Newly created list receiving the annotations.
+   */
+  copyListAnnotations(source, target) {
+    source.annotationMap.forEach((annotation, key) => {
+      target.annotationMap.set(key, annotation.clone());
+    });
+  }
+  /**
+   * Compare list annotations independently of map/object insertion order. Map keys
+   * are compared separately because rendering annotations such as LIST intentionally
+   * do not serialize to the DTO but still affect the rendered list.
+   * Array order remains significant because it can affect rendered class order.
+   *
+   * @param {RTEListBlock} first - First list to compare.
+   * @param {RTEListBlock} second - Second list to compare.
+   * @returns {boolean} Whether both list containers have equivalent annotations.
+   */
+  haveSameListAnnotations(first, second) {
+    var _a, _b;
+    const firstKeys = Array.from(first.annotationMap.keys()).sort();
+    const secondKeys = Array.from(second.annotationMap.keys()).sort();
+    if (JSON.stringify(firstKeys) !== JSON.stringify(secondKeys)) {
+      return false;
+    }
+    return (JSON.stringify(this.normalizeAnnotationValue((_a = first.toJSON().annotations) !== null && _a !== void 0 ? _a : {})) ===
+      JSON.stringify(this.normalizeAnnotationValue((_b = second.toJSON().annotations) !== null && _b !== void 0 ? _b : {})));
+  }
+  /**
+   * Recursively sort object keys for stable annotation comparison.
+   *
+   * @param {unknown} value - Annotation value to normalize.
+   * @returns {unknown} Normalized annotation value.
+   */
+  normalizeAnnotationValue(value) {
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeAnnotationValue(item));
+    }
+    if (value && typeof value === 'object') {
+      const record = value;
+      return Object.keys(record)
+        .sort()
+        .reduce((normalized, key) => {
+        normalized[key] = this.normalizeAnnotationValue(record[key]);
+        return normalized;
+      }, {});
+    }
+    return value;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-item-replace-nest-list-strategy.js

@@ -1,15 +1,47 @@
-import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { ListAnnotationStrategy } from './list-annotation-strategy.abstract';
 /**
  * Replace list item nest list strategy.
+ *
+ * This is the single write-through point for `nestList` mutations. It automatically
+ * normalizes the incoming array by merging adjacent lists only when their types
+ * and container annotations match. Styled list boundaries remain independent.
  */
-export class ListItemReplaceNestListStrategy extends ActionHandleStrategy {
+export class ListItemReplaceNestListStrategy extends ListAnnotationStrategy {
   /**
    * @inheritDoc
    */
   handleAction(action, target) {
-    action.newList.forEach((listBlock) => {
+    const normalized = this.mergeAdjacentSameType(action.newList);
+    normalized.forEach((listBlock) => {
       listBlock.parent = target;
     });
-    target.nestList = action.newList;
+    target.nestList = normalized;
+  }
+  /**
+   * Merge adjacent entries that share the same list type and annotations.
+   * This is an idempotent O(n) pass — calling it on an already-normalized array is a no-op.
+   *
+   * @param {RTEListBlock[]} lists - The nest list array to normalize.
+   * @returns {RTEListBlock[]} A new array with adjacent same-type entries merged.
+   */
+  mergeAdjacentSameType(lists) {
+    if (lists.length <= 1) {
+      return lists;
+    }
+    const merged = [lists[0]];
+    for (let i = 1; i < lists.length; i++) {
+      const prev = merged[merged.length - 1];
+      const current = lists[i];
+      if (prev.type === current.type && this.haveSameListAnnotations(prev, current)) {
+        current.children.forEach((item) => {
+          item.parent = prev;
+        });
+        prev.children = prev.children.concat(current.children);
+      }
+      else {
+        merged.push(current);
+      }
+    }
+    return merged;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-items-strategy.abstract.js

@@ -0,0 +1,27 @@
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * Shared base strategy for list-item operations that require ordered contiguous
+ * item selection within the same target list.
+ */
+export class AbstractListItemsStrategy extends ActionHandleStrategy {
+  /**
+   * Returns selected list items ordered by their position in target and validated
+   * as a contiguous range. Returns an empty array when selection is invalid.
+   *
+   * @param {RTEListBlock} target - The target list block containing selected items.
+   * @param {RTEListItemBlock[]} selectedBlocks - Selected list items from action payload.
+   * @returns {RTEListItemBlock[]} Ordered contiguous selected items, or empty array.
+   */
+  getOrderedContiguousItems(target, selectedBlocks) {
+    const orderedItems = [...selectedBlocks].sort((a, b) => target.children.indexOf(a) - target.children.indexOf(b));
+    const startIndex = target.children.indexOf(orderedItems[0]);
+    if (startIndex < 0) {
+      return [];
+    }
+    return target.children
+      .slice(startIndex, startIndex + orderedItems.length)
+      .every((item, index) => item === orderedItems[index])
+      ? orderedItems
+      : [];
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-nest-items-strategy.js

@@ -0,0 +1,74 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
+import { RTEListBlock } from '../../blocks/list-block';
+import { AbstractListItemsStrategy } from './list-items-strategy.abstract';
+/**
+ * Move selected list items into a nested list under the previous sibling.
+ */
+export class ListNestItemsStrategy extends AbstractListItemsStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    var _a, _b;
+    const selectedItems = this.getOrderedContiguousItems(target, action.selectedBlocks);
+    if (!selectedItems.length) {
+      return;
+    }
+    const startIndex = target.children.indexOf(selectedItems[0]);
+    if (startIndex <= 0) {
+      return;
+    }
+    const previousSibling = target.children[startIndex - 1];
+    const selectedItemSet = new Set(selectedItems);
+    // Tab behavior intentionally keeps using the last nested list entry if present,
+    // even when mixed nested-list types exist, to preserve current behavior.
+    // This also matches the behavior of other rich text editors, especially CKEditor.
+    let nestedList = (_a = previousSibling.nestList) === null || _a === void 0 ? void 0 : _a[previousSibling.nestList.length - 1];
+    if (!nestedList) {
+      nestedList = new RTEListBlock(generateUUID(), target.type);
+      previousSibling.apply(new ReplaceNestListAction([...((_b = previousSibling.nestList) !== null && _b !== void 0 ? _b : []), nestedList]));
+    }
+    target.children = target.children.filter((item) => !selectedItemSet.has(item));
+    nestedList.children = nestedList.children.concat(selectedItems);
+    selectedItems.forEach((item) => {
+      var _a;
+      item.parent = nestedList;
+      if ((_a = item.nestList) === null || _a === void 0 ? void 0 : _a.length) {
+        this.unifyDescendantNestLists(item, item.nestList[0].type);
+      }
+      item.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+    });
+  }
+  /**
+   * Recursively unify all nestLists of a list item (and its descendants) to the given type.
+   * Adjacent same-type merge is handled automatically by ListItemReplaceNestListStrategy
+   * when ReplaceNestListAction is applied, so this method only needs to set the type.
+   *
+   * @param {RTEListItemBlock} item - The list item whose descendants should be normalized.
+   * @param {RTEListBlock['type']} targetType - The target list type used for normalization.
+   */
+  unifyDescendantNestLists(item, targetType) {
+    var _a;
+    if (!((_a = item.nestList) === null || _a === void 0 ? void 0 : _a.length)) {
+      return;
+    }
+    let typeChanged = false;
+    for (const list of item.nestList) {
+      if (list.type !== targetType) {
+        list.type = targetType;
+        typeChanged = true;
+      }
+      // Recursively unify children
+      for (const child of list.children) {
+        this.unifyDescendantNestLists(child, targetType);
+      }
+    }
+    // If any type was changed, re-apply through ReplaceNestListAction so that the
+    // centralized normalize in ListItemReplaceNestListStrategy merges adjacent same-type entries.
+    if (typeChanged) {
+      item.apply(new ReplaceNestListAction([...item.nestList]));
+    }
+  }
+}