@heartlandone/vega 2.95.0 → 2.96.0

package/dist/cjs/vega-time-picker_2.cjs.entry.js

@@ -17,7 +17,7 @@ const typeGuard = require('./type-guard-f354af8b.js');
 const array = require('./array-249289f2.js');
 const staticSubjectTitle = require('./static-subject-title-70c73b16.js');
 const changeManager = require('./change-manager-a297e4d2.js');
-const elementAppenderSlimmer = require('./element-appender-slimmer-1d6323c2.js');
+const elementAppenderSlimmer = require('./element-appender-slimmer-7773fdab.js');
 const clickOutsideOnlyToDismissStrategy = require('./click-outside-only-to-dismiss-strategy-407f6d1e.js');
 const keyboardManagerSlimmer = require('./keyboard-manager-slimmer-a1223714.js');
 const internalFormFieldValidationRule_abstract = require('./internal-form-field-validation-rule.abstract-07cdff46.js');

package/dist/cjs/vega-tooltip_2.cjs.entry.js

@@ -7,7 +7,7 @@ const component = require('./component-1e352960.js');
 const injectKeyboardManager = require('./inject-keyboard-manager-5a105612.js');
 const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
 const componentUsageRuntimeMetrics = require('./component-usage-runtime-metrics-389d1548.js');
-const elementAppenderSlimmer = require('./element-appender-slimmer-1d6323c2.js');
+const elementAppenderSlimmer = require('./element-appender-slimmer-7773fdab.js');
 const deprecatedPropertySlimmer = require('./deprecated-property-slimmer-300a3929.js');
 require('./keyboard-manager-ca76d4dc.js');
 require('./ui-c91c37a7.js');

package/dist/cjs/vega.cjs.js

@@ -1,11 +1,11 @@
 'use strict';
 
 const index = require('./index-58ea899e.js');
-const appGlobals = require('./app-globals-76815382.js');
+const appGlobals = require('./app-globals-38afea36.js');
 require('./feature-flag-controller-c19d0b58.js');
 require('./global-slimmer-registry-b3bce7e0.js');
 require('./index-3ca118c4.js');
-require('./token-extension-d123d9d0.js');
+require('./token-extension-eb828948.js');
 require('./misc-3d30df91.js');
 require('./ui-c91c37a7.js');
 require('./create-public-api-runtime-metrics-slimmer-91b0cbfb.js');
@@ -25,8 +25,8 @@ require('./static-subject-title-70c73b16.js');
 require('./internal-calendar-period-factory-b76006f7.js');
 require('./type-guard-f354af8b.js');
 require('./typography-3ea4fe41.js');
-require('./link-extension-92a63cb7.js');
-require('./code-block-493c7ce7.js');
+require('./link-extension-b7f99a52.js');
+require('./code-block-4126dc3b.js');
 require('./dom-node-subject-observer-factory-c82df135.js');
 require('./observer-f49483e8.js');
 require('./vega-internal-event-id-ecc5b87a.js');
@@ -36,14 +36,14 @@ require('./tinycolor-polyfill-502efaa8.js');
 require('./vega-nonce-manager-df69d3ed.js');
 require('./index-592b4052.js');
 require('./object-b53e9416.js');
-require('./content-state-fc34a814.js');
+require('./content-state-50e8a03c.js');
 require('./internal-icon-manager-40bcac72.js');
 require('./icon-manager-be358b32.js');
-require('./split-cell-operation-43752212.js');
+require('./split-cell-operation-70be116d.js');
 require('./remote-invocation-registry-fc22fdd0.js');
 require('./pixel-98f2a10c.js');
 require('./timer-5f33058b.js');
-require('./image-extension-30a7c10f.js');
+require('./image-extension-c881c454.js');
 require('./copy-d021c780.js');
 require('./vega-dialog-controller-16be85d5.js');
 require('./valid-credit-card-number-rule-8d370163.js');

package/dist/collection/components/vega-combo-box/vega-combo-box.js

@@ -698,7 +698,7 @@ export class VegaComboBox {
             "name": "vegaVersion",
             "text": "2.95.0"
           }],
-        "text": "An event emitter notifying that the Select All option in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when all items become selected,\nand `false` when Select All is cleared."
+        "text": "An event emitter only fired when the Select All checkbox in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when the Select All checkbox is clicked to select all items,\n   and `false` when the Select All checkbox is clicked to clear all selected items."
       },
       "complexType": {
         "original": "boolean",
@@ -719,7 +719,7 @@ export class VegaComboBox {
             "name": "vegaVersion",
             "text": "2.95.0"
           }],
-        "text": "An event emitter notifying that the Select All option in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when all items become selected,\nand `false` when Select All is cleared."
+        "text": "An event emitter only fired when the Select All checkbox in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when the Select All checkbox is clicked to select all items,\n   and `false` when the Select All checkbox is clicked to clear all selected items."
       },
       "complexType": {
         "original": "boolean",

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

@@ -234,10 +234,33 @@ export class VegaDropdown {
      */
     this.isLazyLoading = false;
     /**
-     * Determines whether the dropdown position is calculated relative to the screen.
+     * Determines whether the dropdown uses viewport-based positioning (`position: fixed`) or container-based positioning (`position: absolute`).
      *
-     * @VegaWarning - It will overrides the positionRelativeTo and matchContainerHeight properties, rendering them ineffective.
-     * 			    - Currently, when set to true, the position calculation may be inaccurate if the popover is placed inside a scrollable container within a shadowRoot (e.g., inside a vega-modal with scrollable content).
+     * **Technical Implementation:**
+     *
+     * - When `false` (default): The dropdown content box renders with `position: absolute` and its coordinates are calculated relative to the nearest positioned ancestor. Combined with `positionRelativeTo`, you can specify which ancestor to measure from, which ensures the menu scrolls together with that ancestor.
+     *
+     * - When `true`: The dropdown content box renders with `position: fixed` and its coordinates are calculated from the viewport. The menu is visually anchored to the trigger element via JavaScript and moves with it on scroll, even though it is not part of the document flow. `positionRelativeTo` has no effect in this mode.
+     *
+     * When to set `isScreenPosition` to `true`:
+     *
+     * - Dropdowns that need to break out of container constraints (non-Shadow-DOM only):
+     *    When you want the dropdown to appear outside its container's boundaries (e.g., to avoid being clipped by a parent's
+     *    `overflow: hidden` or small dimensions), viewport-based positioning allows it to render freely.
+     *    This only works for regular (non-Shadow-DOM) containers. Shadow DOM boundaries cannot be escaped with `position: fixed`.
+     *
+     * - Dropdowns in fixed or sticky positioned containers:
+     *    When the dropdown trigger is inside a fixed or sticky positioned container, viewport-based positioning ensures correct alignment.
+     *
+     * When to keep `isScreenPosition` as `false` (default):
+     *
+     * - Simple layouts where the dropdown and its trigger are not inside scrollable containers
+     * - When you want the dropdown to scroll naturally with its container (using `position: absolute`)
+     * - When you need `positionRelativeTo` to control which ancestor the dropdown is positioned relative to
+     * - When `matchContainerHeight` is needed (this property is overridden when `isScreenPosition` is `true`)
+     *
+     * @VegaWarning - Setting this to `true` override the `positionRelativeTo` and `matchContainerHeight` properties, rendering them ineffective.
+     * 			    - Currently, when set to `true`, the position calculation may be inaccurate if the popover is placed inside a scrollable container within a shadowRoot (e.g., inside a vega-modal with scrollable content).
      * @vegaVersion 2.36.0
      */
     this.isScreenPosition = false;
@@ -982,12 +1005,12 @@ export class VegaDropdown {
       "docs": {
         "tags": [{
             "name": "VegaWarning",
-            "text": "- It will overrides the positionRelativeTo and matchContainerHeight properties, rendering them ineffective.\n- Currently, when set to true, the position calculation may be inaccurate if the popover is placed inside a scrollable container within a shadowRoot (e.g., inside a vega-modal with scrollable content)."
+            "text": "- Setting this to `true` override the `positionRelativeTo` and `matchContainerHeight` properties, rendering them ineffective.\n- Currently, when set to `true`, the position calculation may be inaccurate if the popover is placed inside a scrollable container within a shadowRoot (e.g., inside a vega-modal with scrollable content)."
           }, {
             "name": "vegaVersion",
             "text": "2.36.0"
           }],
-        "text": "Determines whether the dropdown position is calculated relative to the screen."
+        "text": "Determines whether the dropdown uses viewport-based positioning (`position: fixed`) or container-based positioning (`position: absolute`).\n\n**Technical Implementation:**\n\n- When `false` (default): The dropdown content box renders with `position: absolute` and its coordinates are calculated relative to the nearest positioned ancestor. Combined with `positionRelativeTo`, you can specify which ancestor to measure from, which ensures the menu scrolls together with that ancestor.\n\n- When `true`: The dropdown content box renders with `position: fixed` and its coordinates are calculated from the viewport. The menu is visually anchored to the trigger element via JavaScript and moves with it on scroll, even though it is not part of the document flow. `positionRelativeTo` has no effect in this mode.\n\nWhen to set `isScreenPosition` to `true`:\n\n- Dropdowns that need to break out of container constraints (non-Shadow-DOM only):\n   When you want the dropdown to appear outside its container's boundaries (e.g., to avoid being clipped by a parent's\n   `overflow: hidden` or small dimensions), viewport-based positioning allows it to render freely.\n   This only works for regular (non-Shadow-DOM) containers. Shadow DOM boundaries cannot be escaped with `position: fixed`.\n\n- Dropdowns in fixed or sticky positioned containers:\n   When the dropdown trigger is inside a fixed or sticky positioned container, viewport-based positioning ensures correct alignment.\n\nWhen to keep `isScreenPosition` as `false` (default):\n\n- Simple layouts where the dropdown and its trigger are not inside scrollable containers\n- When you want the dropdown to scroll naturally with its container (using `position: absolute`)\n- When you need `positionRelativeTo` to control which ancestor the dropdown is positioned relative to\n- When `matchContainerHeight` is needed (this property is overridden when `isScreenPosition` is `true`)"
       },
       "attribute": "is-screen-position",
       "reflect": false,
@@ -1155,7 +1178,7 @@ export class VegaDropdown {
             "name": "vegaVersion",
             "text": "2.93.0"
           }],
-        "text": "An event emitter notifying that the Select All option has been clicked.\n\nThe event's `detail` property is `true` when all items become selected,\nand `false` when Select All is cleared."
+        "text": "An event emitter only fired when the Select All checkbox has been clicked.\n\nThe event's `detail` property is `true` when the Select All checkbox is clicked to select all items,\n   and `false` when the Select All checkbox is clicked to clear all selected items."
       },
       "complexType": {
         "original": "boolean",
@@ -1176,7 +1199,7 @@ export class VegaDropdown {
             "name": "vegaVersion",
             "text": "2.93.0"
           }],
-        "text": "An event emitter notifying that the Select All option has been clicked.\n\nThe event's `detail` property is `true` when all items become selected,\nand `false` when Select All is cleared."
+        "text": "An event emitter only fired when the Select All checkbox has been clicked.\n\nThe event's `detail` property is `true` when the Select All checkbox is clicked to select all items,\n   and `false` when the Select All checkbox is clicked to clear all selected items."
       },
       "complexType": {
         "original": "boolean",

package/dist/collection/components/vega-input-select/vega-input-select.js

@@ -925,7 +925,7 @@ export class VegaInputSelect {
             "name": "vegaVersion",
             "text": "2.95.0"
           }],
-        "text": "An event emitter notifying that the Select All option in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when all items become selected,\nand `false` when Select All is cleared."
+        "text": "An event emitter only fired when the Select All checkbox in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when the Select All checkbox is clicked to select all items,\n   and `false` when the Select All checkbox is clicked to clear all selected items."
       },
       "complexType": {
         "original": "boolean",
@@ -946,7 +946,7 @@ export class VegaInputSelect {
             "name": "vegaVersion",
             "text": "2.95.0"
           }],
-        "text": "An event emitter notifying that the Select All option in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when all items become selected,\nand `false` when Select All is cleared."
+        "text": "An event emitter only fired when the Select All checkbox in the dropdown has been clicked.\n\nThe event's `detail` property is `true` when the Select All checkbox is clicked to select all items,\n   and `false` when the Select All checkbox is clicked to clear all selected items."
       },
       "complexType": {
         "original": "boolean",

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]));
+    }
+  }
+}

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

@@ -1,5 +1,9 @@
 import { RemoveChildrenAction } from '../../actions/remove-child-action';
+import { InsertChildrenAfterAction } from '../../actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../actions/insert-children-before-block';
 import { RemoveNestListAction } from '../../actions/remove-nest-list-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { RemoveChildrenStrategy } from './remove-children-strategy';
 /**
  * List remove list item strategy.
@@ -12,16 +16,92 @@ export class ListRemoveListItemStrategy extends RemoveChildrenStrategy {
    * @param {RTEListBlock} target - The list block.
    */
   handleAction(action, target) {
+    var _a, _b;
+    const removingListItem = action.entityToBeRemoved instanceof RTEListItemBlock ? action.entityToBeRemoved : null;
+    const removingIndex = removingListItem ? target.children.indexOf(removingListItem) : -1;
+    if (((_a = removingListItem === null || removingListItem === void 0 ? void 0 : removingListItem.nestList) === null || _a === void 0 ? void 0 : _a.length) && removingIndex >= 0) {
+      this.promoteNestListsToUpperLevel(removingListItem, target, removingIndex);
+    }
     super.handleAction(action, target);
     const parent = target.parent;
     if (target.children.length === 0 && parent) {
       // The parent is a list item mean the current block is a nest list, so we need to use RemoveNestListAction to remove the item
       if (parent['type'] === 'list-item') {
-        parent.apply(new RemoveNestListAction(target));
+        const parentListItem = parent;
+        if ((_b = parentListItem.nestList) === null || _b === void 0 ? void 0 : _b.includes(target)) {
+          parentListItem.apply(new RemoveNestListAction(target));
+        }
       }
       else {
         parent.apply(new RemoveChildrenAction(target));
       }
     }
   }
+  /**
+   * Promote nested lists of the list item being removed by one level.
+   *
+   * Same-type nested lists are flattened into the current (target) list to avoid
+   * creating redundant list wrappers. Different-type nested lists stay nested under
+   * the parent list item as siblings of the target list, positioned relative to the
+   * target so document order is preserved. When the parent is the root content, the
+   * different-type lists are inserted right after the target list instead.
+   *
+   * @param {RTEListItemBlock} removingListItem - The list item being removed.
+   * @param {RTEListBlock} target - The list currently containing the item.
+   * @param {number} removingIndex - The original index of the removing item.
+   */
+  promoteNestListsToUpperLevel(removingListItem, target, removingIndex) {
+    var _a, _b;
+    const promotedLists = [...((_a = removingListItem.nestList) !== null && _a !== void 0 ? _a : [])];
+    let insertionIndex = removingIndex + 1;
+    const differentTypeLists = [];
+    promotedLists.forEach((listBlock) => {
+      if (listBlock.type === target.type) {
+        const promotedItems = [...listBlock.children];
+        if (promotedItems.length > 0) {
+          promotedItems.forEach((item) => {
+            item.parent = target;
+          });
+          target.children.splice(insertionIndex, 0, ...promotedItems);
+          insertionIndex += promotedItems.length;
+        }
+      }
+      else {
+        differentTypeLists.push(listBlock);
+      }
+    });
+    const parent = target.parent;
+    if (differentTypeLists.length > 0 && parent instanceof RTEListItemBlock) {
+      // Different-type promoted lists stay nested under the parent item, as siblings
+      // of the target list. When the removed item was merged into the parent, its
+      // own nested lists follow it up one level and belong to the parent item — not
+      // flattened into the grandparent list. Position them relative to the target so
+      // document order is preserved.
+      const currentNestLists = [...((_b = parent.nestList) !== null && _b !== void 0 ? _b : [])];
+      const targetIndex = currentNestLists.indexOf(target);
+      if (targetIndex >= 0) {
+        // When removing the first item, its nested lists were visually above the
+        // remaining items, so they must be placed before the target list to
+        // preserve document order.
+        const insertAt = removingIndex === 0 ? targetIndex : targetIndex + 1;
+        currentNestLists.splice(insertAt, 0, ...differentTypeLists);
+      }
+      else {
+        currentNestLists.push(...differentTypeLists);
+      }
+      parent.apply(new ReplaceNestListAction(currentNestLists));
+    }
+    else if (differentTypeLists.length > 0) {
+      // Mirror the nested-parent ordering rule: when removing the first item,
+      // its nested lists were visually above the remaining items, so insert
+      // before the target to preserve document order.
+      if (removingIndex === 0) {
+        parent.apply(new InsertChildrenBeforeAction(target, ...differentTypeLists));
+      }
+      else {
+        parent.apply(new InsertChildrenAfterAction(target, ...differentTypeLists));
+      }
+    }
+    removingListItem.apply(new ReplaceNestListAction([]));
+  }
 }

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

@@ -0,0 +1,30 @@
+/**
+ * Normalize a mixed paragraph/list selection before rebuilding it as a list.
+ *
+ * Selected list items whose owning ancestor item is also selected remain inside
+ * that ancestor's nestList instead of being emitted again as flattened siblings.
+ * Their immediate list type is still updated because the nested item was part of
+ * the toolbar selection.
+ *
+ * @param {RTEBlock[]} selectedBlocks - Blocks selected by the toolbar action.
+ * @param {ListType} listType - Target list type.
+ * @returns {RTEBlock[]} Top-level selected blocks to emit into the rebuilt list.
+ */
+export function normalizeMixedListSelection(selectedBlocks, listType) {
+  const selectedListItems = new Set(selectedBlocks.filter((block) => block.dtoName === 'RTEListItemBlock'));
+  return selectedBlocks.filter((block) => {
+    if (!(block.dtoName === 'RTEListItemBlock')) {
+      return true;
+    }
+    let parentList = block.parent;
+    while (parentList.parent && parentList.parent.dtoName === 'RTEListItemBlock') {
+      const ownerItem = parentList.parent;
+      if (selectedListItems.has(ownerItem)) {
+        block.parent.type = listType;
+        return false;
+      }
+      parentList = ownerItem.parent;
+    }
+    return true;
+  });
+}