@heartlandone/vega 2.94.0 → 2.96.0

package/dist/collection/components/vega-rich-text-editor/dto/content-state.js

@@ -24,6 +24,7 @@ import { LogUtility } from '../../../utils/log';
 import { HTMLContentCleaner } from '../slimmers/controllers/html-cleaner';
 import { RTEFilterStylesStrategyRegistry } from './filter-styles-strategies/filter-styles-strategy-registry';
 import { DeleteSelectedContentStrategy } from './action-handle-strategies/modify-content-strategies/delete-selected-content-strategy';
+import { ReplaceNestListAction } from './actions/replace-nest-list-action';
 /**
  * Class representing the content state of the rich text editor.
  */
@@ -191,14 +192,19 @@ export class VegaRTEContent {
   /**
    * Convert text to list.
    *
-   * @param {RTETextBlock} block - block
+   * @param {RTETextBlock | RTEListItemBlock} block - Block to convert or rebuild.
    * @returns {RTEListItemBlock} list item block dto.
    */
   toListItem(block) {
+    var _a;
     block.children.map((node) => node.apply(new SyncUpSelectionAction()));
     const listItemBlock = new RTEListItemBlock(generateUUID());
     listItemBlock.apply(new AppendChildrenAction(block['children']));
     listItemBlock['annotationMap'] = block['annotationMap'];
+    if (block instanceof RTEListItemBlock && ((_a = block.nestList) === null || _a === void 0 ? void 0 : _a.length)) {
+      listItemBlock.apply(new ReplaceNestListAction([...block.nestList]));
+      block.apply(new ReplaceNestListAction([]));
+    }
     return listItemBlock;
   }
   /**

package/dist/collection/components/vega-rich-text-editor/dto/filter-styles-strategies/list-block/list-block-filter-styles-strategy.js

@@ -27,10 +27,14 @@ export class ListBlockFilterStylesStrategy extends RTEFilterStylesStrategy {
    * @inheritDoc
    */
   toCssText() {
-    const selector = this.elementTagName
-      .split(',')
-      .map((tag) => `.${RTEFilterStylesStrategy.RTE_CONTENT_CONTAINER_CLASS_NAME} ${tag.trim()}`)
+    const containerClass = RTEFilterStylesStrategy.RTE_CONTENT_CONTAINER_CLASS_NAME;
+    const tags = this.elementTagName.split(',').map((tag) => tag.trim());
+    const baseSelector = tags.map((tag) => `.${containerClass} ${tag}`).join(', ');
+    const markerSelector = tags
+      .map((tag) => `.${containerClass} ${tag} > li::marker`)
       .join(', ');
-    return `${selector} { ${this.convertStylesMapToCssText(this.stylesToBeFiltered)} }`;
+    const markerStyles = this.convertStylesMapToCssText(ListAnnotation.getDefaultMarkerStyles());
+    return (`${baseSelector} { ${this.convertStylesMapToCssText(this.stylesToBeFiltered)} } ` +
+      `${markerSelector} { ${markerStyles} }`);
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/list-block-renderer.js

@@ -1,10 +1,43 @@
 import { h } from '@stencil/core';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
 import { RTEBlockRenderer } from './block-renderer.abstract';
 import RTEListItemBlockRenderer from './list-item-block-renderer';
+const defaultOrderedListMarkerRule = ['decimal', 'lower-alpha', 'lower-roman'];
+const defaultBulletListMarkerRule = ['disc', 'circle', 'square'];
 class RTEListBlockRenderer extends RTEBlockRenderer {
   render(block, renderContext) {
     const BlockTag = block.getBlockTag();
-    return (h(BlockTag, Object.assign({}, this.getCustomAttrs(block), { key: block.id, ref: (ref) => super.registerRef(ref, block), style: block.getStyles(), class: block.getClasses() }), block.children.map((listItemBlock) => RTEListItemBlockRenderer.render(listItemBlock, renderContext))));
+    const styles = block.getStyles(renderContext);
+    const resolvedListMarker = this.resolveListMarker(block, styles);
+    if (resolvedListMarker) {
+      styles.listStyleType = resolvedListMarker;
+    }
+    return (h(BlockTag, Object.assign({}, this.getCustomAttrs(block), { key: block.id, ref: (ref) => super.registerRef(ref, block), style: styles, class: block.getClasses() }), block.children.map((listItemBlock) => RTEListItemBlockRenderer.render(listItemBlock, renderContext))));
+  }
+  resolveListMarker(block, styles) {
+    if (styles.listStyleType || styles['list-style-type']) {
+      return undefined;
+    }
+    const depth = this.getListDepth(block, block.type);
+    if (block.type === 'number-list') {
+      return defaultOrderedListMarkerRule[depth % defaultOrderedListMarkerRule.length];
+    }
+    if (block.type === 'bullet-list') {
+      return defaultBulletListMarkerRule[depth % defaultBulletListMarkerRule.length];
+    }
+    return undefined;
+  }
+  getListDepth(block, targetType) {
+    let depth = 0;
+    let currentList = block;
+    while (currentList.parent instanceof RTEListItemBlock) {
+      const parentList = currentList.parent.parent;
+      if (parentList.type === targetType) {
+        depth++;
+      }
+      currentList = parentList;
+    }
+    return depth;
   }
 }
 export default new RTEListBlockRenderer();

package/dist/collection/components/vega-rich-text-editor/dto/renderers/blocks/list-item-block-renderer.js

@@ -3,9 +3,26 @@ import RTEListBlockRenderer from './list-block-renderer';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
   render(block, renderContext) {
-    return (h("li", Object.assign({}, this.getCustomAttrs(block), { key: block.id, ref: (ref) => super.registerRef(ref, block), style: block.getStyles(), class: block.getClasses() }),
-      super.renderNodes(block, renderContext),
-      this.renderChildren(block.nestList, renderContext)));
+    var _a;
+    const hasNestList = ((_a = block.nestList) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    return (h("li", Object.assign({}, this.getCustomAttrs(block), { key: this.getRenderKey(block), ref: (ref) => super.registerRef(ref, block), style: block.getStyles(), class: block.getClasses() }),
+      hasNestList ? (
+      // Keep text nodes wrapped as a block-level element when a nested list exists.
+      // This preserves stable marker/text flow and selection behavior before the child list.
+      h("span", { style: { display: 'block' } }, super.renderNodes(block, renderContext))) : (super.renderNodes(block, renderContext)),
+      hasNestList && this.renderChildren(block.nestList, renderContext)));
+  }
+  /**
+   * Include structural ownership and direct nested-list identity in the key so
+   * list mutations recreate the li when its rendered child shape changes.
+   *
+   * @param {RTEListItemBlock} block - List item being rendered.
+   * @returns {string} Structure-aware render key.
+   */
+  getRenderKey(block) {
+    var _a;
+    const nestListIds = ((_a = block.nestList) !== null && _a !== void 0 ? _a : []).map((list) => list.id);
+    return JSON.stringify([block.parent.id, block.id, nestListIds]);
   }
   renderChildren(children, renderContext) {
     return children === null || children === void 0 ? void 0 : children.map((block) => RTEListBlockRenderer.render(block, renderContext));

package/dist/collection/components/vega-rich-text-editor/extensions/table/annotation-handler/table-annotation-handler-base.js

@@ -33,12 +33,29 @@ export class TableAnnotationHandlerBase extends AnnotationGeneratorStrategyAbstr
       const updatedBorderColor = borderColor === 'initial' ? '' : borderColor;
       return {
         style: borderStyle === 'initial' ? '' : borderStyle,
-        width: borderWidth === 'initial' ? '' : borderWidth,
+        width: this.normalizeBorderWidth(borderWidth),
         color: RTETableColorManager.getColorKey(updatedBorderColor) || updatedBorderColor,
       };
     }
     return null;
   }
+  /**
+   * Normalize a border width read from the DOM, dropping the `initial` value and the
+   * CSS keyword widths (`thin`/`medium`/`thick`). Those only appear as serialization
+   * artifacts of shorthand borders (e.g. `border: none` → `border-width: medium`) and
+   * are not valid numeric dimensions, so leaving them in would populate the properties
+   * "Weight" field with an invalid value and block the whole form from saving.
+   *
+   * @param {string} borderWidth - The raw border width read from the element style.
+   * @returns {string} The normalized border width (empty string when it is a keyword).
+   */
+  normalizeBorderWidth(borderWidth) {
+    if (borderWidth === 'initial' ||
+      TableAnnotationHandlerBase.BORDER_WIDTH_KEYWORDS.includes(borderWidth)) {
+      return '';
+    }
+    return borderWidth;
+  }
   /**
    * Extract width from element.
    *
@@ -76,3 +93,10 @@ export class TableAnnotationHandlerBase extends AnnotationGeneratorStrategyAbstr
     return null;
   }
 }
+/**
+ * CSS border-width keywords. These are produced as serialization artifacts when a
+ * shorthand border without an explicit width is round-tripped (e.g. `border: none`
+ * expands to `border-width: medium`). They are not valid numeric dimensions for the
+ * table/cell properties "Weight" field, so they are normalized away on import.
+ */
+TableAnnotationHandlerBase.BORDER_WIDTH_KEYWORDS = ['thin', 'medium', 'thick'];

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/li-to-rte-list-item-block-strategy.js

@@ -53,6 +53,8 @@ export class LiToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstrac
    */
   appendChildBlocks(currentBlock, childBlocks) {
     currentBlock.nestList = childBlocks.filter((block) => ['bullet-list', 'number-list'].includes(block.type));
+    // Maintain bidirectional parent link so that nested list blocks can traverse up to the list item.
+    currentBlock.nestList.forEach((block) => (block.parent = currentBlock));
   }
   /**
    * Should continue process to child elements.

package/dist/collection/components/vega-rich-text-editor/slimmers/controllers/helper/input-event-handler/abstract-delete-content-handler.js

@@ -61,11 +61,25 @@ export class AbstractDeleteContentHandler extends BaseHandler {
    * @returns {Nullable<RTENode>} The next node, or null when the given node is the last node of the content.
    */
   getNextNode(node) {
+    var _a;
     const block = node.parent;
     const nodeIndex = block.children.indexOf(node);
     if (nodeIndex >= 0 && nodeIndex < block.children.length - 1) {
       return block.children[nodeIndex + 1];
     }
+    // When the caret is at the end of a list item that owns nested lists, the next
+    // caret position is the first node of the first non-empty nested list, not the following sibling
+    // block. Descend into the item's own nestList before ascending to siblings so that
+    // a forward delete merges the first nested item up instead of skipping the whole
+    // nested list and merging the following sibling into the deepest nested item.
+    if (block.isListItemBlock() && ((_a = block.nestList) === null || _a === void 0 ? void 0 : _a.length)) {
+      for (const nestedList of block.nestList) {
+        const firstNestedNode = nestedList.getFirstNode();
+        if (firstNestedNode) {
+          return firstNestedNode;
+        }
+      }
+    }
     const nextBlock = this.getNextBlock(block);
     return nextBlock ? nextBlock.getFirstNode() : null;
   }
@@ -76,10 +90,25 @@ export class AbstractDeleteContentHandler extends BaseHandler {
    * @returns {Nullable<RTEBlock>} The next block, or null when the given block is the last block of the content.
    */
   getNextBlock(block) {
+    var _a, _b;
     const parent = block.parent;
     if (!parent || !parent.children) {
       return null;
     }
+    // Nested lists are owned through a list item's nestList collection rather than
+    // its children collection. Traverse the remaining nested-list branches before
+    // ascending to the owning item and its following siblings.
+    if (parent instanceof RTEBlock && parent.isListItemBlock()) {
+      const nestedListIndex = ((_a = parent.nestList) !== null && _a !== void 0 ? _a : []).indexOf(block);
+      if (nestedListIndex >= 0) {
+        for (const nestedList of ((_b = parent.nestList) !== null && _b !== void 0 ? _b : []).slice(nestedListIndex + 1)) {
+          if (nestedList.getFirstNode()) {
+            return nestedList;
+          }
+        }
+        return this.getNextBlock(parent);
+      }
+    }
     const siblings = parent.children;
     const blockIndex = siblings.indexOf(block);
     if (blockIndex >= 0 && siblings[blockIndex + 1]) {

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/bullets-numbers-toolbar-button-slimmer.js

@@ -5,10 +5,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { h } from '@stencil/core';
-import { InjectVegaSlimmer, MapToComponentField, MapToComponentMethod } from 'vega-slimmer/core';
+import { InjectVegaSlimmer, MapToComponentField, MapToComponentMethod, methodPlaceholder, } from 'vega-slimmer/core';
 import { VegaInternalIconManager } from '../../../../../../helpers/icon/internal-icon-manager';
 import ListUL from '../../../../assets/list-ul';
 import ListOL from '../../../../assets/list-ol';
+import { ListKeyboardSlimmer } from './list-keyboard-slimmer';
 import { BulletsToolbarButtonSlimmer } from './bullets-toolbar-button-slimmer';
 import { NumbersToolbarButtonSlimmer } from './numbers-toolbar-button-slimmer';
 import { VisualModeToolbarButtonSlimmer } from '../visual-mode-toolbar-button-slimmer.abstract';
@@ -24,6 +25,13 @@ export class BulletsNumbersToolbarButtonSlimmer extends VisualModeToolbarButtonS
     });
     this.bulletsToolbarButtonSlimmer = new BulletsToolbarButtonSlimmer();
     this.numbersToolbarButtonSlimmer = new NumbersToolbarButtonSlimmer();
+    this.listKeyboardSlimmer = new ListKeyboardSlimmer();
+  }
+  disconnectedCallback() {
+    methodPlaceholder();
+  }
+  componentDidLoad() {
+    methodPlaceholder();
   }
   componentWillRender() {
     if (this.numbersToolbarButtonSlimmer.isSelected()) {
@@ -86,12 +94,33 @@ export class BulletsNumbersToolbarButtonSlimmer extends VisualModeToolbarButtonS
 __decorate([
   MapToComponentField()
 ], BulletsNumbersToolbarButtonSlimmer.prototype, "selectionController", void 0);
+__decorate([
+  MapToComponentField()
+], BulletsNumbersToolbarButtonSlimmer.prototype, "valueController", void 0);
+__decorate([
+  MapToComponentField()
+], BulletsNumbersToolbarButtonSlimmer.prototype, "value", void 0);
+__decorate([
+  MapToComponentField()
+], BulletsNumbersToolbarButtonSlimmer.prototype, "toolbarItems", void 0);
+__decorate([
+  MapToComponentField()
+], BulletsNumbersToolbarButtonSlimmer.prototype, "vegaRichTextEditorRenderer", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], BulletsNumbersToolbarButtonSlimmer.prototype, "bulletsToolbarButtonSlimmer", void 0);
 __decorate([
   InjectVegaSlimmer()
 ], BulletsNumbersToolbarButtonSlimmer.prototype, "numbersToolbarButtonSlimmer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], BulletsNumbersToolbarButtonSlimmer.prototype, "listKeyboardSlimmer", void 0);
+__decorate([
+  MapToComponentMethod('disconnectedCallback')
+], BulletsNumbersToolbarButtonSlimmer.prototype, "disconnectedCallback", null);
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], BulletsNumbersToolbarButtonSlimmer.prototype, "componentDidLoad", null);
 __decorate([
   MapToComponentMethod('componentWillRender')
 ], BulletsNumbersToolbarButtonSlimmer.prototype, "componentWillRender", null);

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/helper/abstract-list-keyboard-handler.js

@@ -0,0 +1,204 @@
+import { RTEListItemBlock } from '../../../../../dto/blocks/list-item-block';
+/**
+ * Abstract base for list keyboard (Tab / Shift+Tab) handlers.
+ * Provides shared selection-normalization utilities used by both the indent
+ * and outdent concrete handlers.
+ */
+export class AbstractListKeyboardHandler {
+  /**
+   * Filter the ordered selection down to only the "root" items —
+   * items whose ancestor is not also present in the selection.
+   *
+   * @param {RTEListItemBlock[]} selection - Ordered selected list items.
+   * @returns {RTEListItemBlock[]} Root items that do not have selected ancestors.
+   */
+  getOutdentRoots(selection) {
+    const selectedItems = new Set(selection);
+    return selection.filter((item) => !this.hasSelectedAncestor(item, selectedItems));
+  }
+  /**
+   * Check whether a list item has an ancestor that is also selected.
+   *
+   * @param {RTEListItemBlock} item - Item to inspect.
+   * @param {Set<RTEListItemBlock>} selectedItems - Selected items lookup set.
+   * @returns {boolean} True when an ancestor item is selected.
+   */
+  hasSelectedAncestor(item, selectedItems) {
+    var _a, _b;
+    let currentParent = (_a = item.parent) === null || _a === void 0 ? void 0 : _a.parent;
+    while (currentParent instanceof RTEListItemBlock) {
+      if (selectedItems.has(currentParent)) {
+        return true;
+      }
+      currentParent = (_b = currentParent.parent) === null || _b === void 0 ? void 0 : _b.parent;
+    }
+    return false;
+  }
+  /**
+   * Split an ordered flat list of items into groups that share the same
+   * parent list and are contiguous siblings.
+   *
+   * @param {RTEListItemBlock[]} selection - Ordered list-item selection.
+   * @returns {RTEListItemBlock[][]} Contiguous parent-based segments.
+   */
+  splitSelectionIntoParentSegments(selection) {
+    const segments = [];
+    let currentSegment = [];
+    selection.forEach((item) => {
+      if (currentSegment.length === 0) {
+        currentSegment.push(item);
+        return;
+      }
+      const previousItem = currentSegment[currentSegment.length - 1];
+      const isSameParent = previousItem.parent === item.parent;
+      const isContiguousSibling = isSameParent &&
+        item.parent.children.indexOf(item) - item.parent.children.indexOf(previousItem) === 1;
+      if (isContiguousSibling) {
+        currentSegment.push(item);
+        return;
+      }
+      segments.push(currentSegment);
+      currentSegment = [item];
+    });
+    if (currentSegment.length > 0) {
+      segments.push(currentSegment);
+    }
+    return segments;
+  }
+  /**
+   * Normalize the selection and split into parent-based contiguous segments.
+   * Returns null when the result is empty.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[][] | null} Contiguous segments or null when invalid.
+   */
+  normalizeToSegments(selectedBlocks) {
+    const normalizedSelection = this.getOrderedListItems(selectedBlocks);
+    if (!normalizedSelection) {
+      return null;
+    }
+    const roots = this.getOutdentRoots(normalizedSelection);
+    const segments = this.splitSelectionIntoParentSegments(roots);
+    return segments.length ? segments : null;
+  }
+  /**
+   * Return the first and last RTETextNode spanning the provided blocks,
+   * or null when either boundary cannot be resolved.
+   *
+   * @param {RTEBlock[]} blocks - Blocks defining the range boundary.
+   * @returns {Nullable<[RTETextNode, RTETextNode]>} First and last boundary nodes.
+   */
+  getSelectionBoundary(blocks) {
+    var _a, _b, _c, _d;
+    const firstNode = (_b = (_a = blocks[0]) === null || _a === void 0 ? void 0 : _a.getFirstNode()) !== null && _b !== void 0 ? _b : null;
+    const lastNode = (_d = (_c = blocks[blocks.length - 1]) === null || _c === void 0 ? void 0 : _c.getLastNode()) !== null && _d !== void 0 ? _d : null;
+    if (!firstNode || !lastNode) {
+      return null;
+    }
+    return [firstNode, lastNode];
+  }
+  /**
+   * Normalize the raw selectedBlocks into an ordered list of RTEListItemBlocks,
+   * truncating at the first non-list block.  Returns null when no list items
+   * are present.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[] | null} Ordered list items or null.
+   */
+  getOrderedListItems(selectedBlocks) {
+    const selectedListItems = this.getSelectedListItemsUntilFirstNonList(selectedBlocks);
+    if (!selectedListItems.length) {
+      return null;
+    }
+    return [...selectedListItems].sort((a, b) => this.compareTreePath(this.getTreePath(a), this.getTreePath(b)));
+  }
+  /**
+   * Collect contiguous selected list items until a non-list block is found.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[]} Selected list items up to first non-list block.
+   */
+  getSelectedListItemsUntilFirstNonList(selectedBlocks) {
+    const selectedListItems = [];
+    for (const block of selectedBlocks) {
+      if (!(block instanceof RTEListItemBlock)) {
+        if (selectedListItems.length > 0) {
+          break;
+        }
+        return [];
+      }
+      selectedListItems.push(block);
+    }
+    return selectedListItems;
+  }
+  /**
+   * Build a hierarchical index path for a list item in the list tree.
+   *
+   * @param {RTEListItemBlock} item - Item whose tree path is being resolved.
+   * @returns {number[]} Tree index path from root to the item.
+   */
+  getTreePath(item) {
+    var _a;
+    const path = [];
+    const visitedLists = new Set();
+    let currentItem = item;
+    let currentList = item.parent;
+    while (currentList && this.hasChildren(currentList) && !visitedLists.has(currentList)) {
+      visitedLists.add(currentList);
+      const itemIndex = currentList.children.indexOf(currentItem);
+      if (itemIndex < 0) {
+        break;
+      }
+      path.unshift(itemIndex);
+      const listParent = currentList.parent;
+      if (listParent instanceof RTEListItemBlock) {
+        const nestListIndex = ((_a = listParent.nestList) !== null && _a !== void 0 ? _a : []).indexOf(currentList);
+        if (nestListIndex < 0) {
+          break;
+        }
+        path.unshift(nestListIndex);
+        currentItem = listParent;
+        currentList = listParent.parent;
+        continue;
+      }
+      let child = currentList;
+      let container = listParent;
+      while (container && this.hasChildren(container)) {
+        const childIndex = container.children.indexOf(child);
+        if (childIndex < 0) {
+          return path;
+        }
+        path.unshift(childIndex);
+        child = container;
+        container = container.parent;
+      }
+      break;
+    }
+    return path;
+  }
+  /**
+   * Compare two list-item tree paths.
+   *
+   * @param {number[]} a - First tree path.
+   * @param {number[]} b - Second tree path.
+   * @returns {number} Negative when a < b, positive when a > b, otherwise 0.
+   */
+  compareTreePath(a, b) {
+    const length = Math.min(a.length, b.length);
+    for (let i = 0; i < length; i++) {
+      if (a[i] !== b[i]) {
+        return a[i] - b[i];
+      }
+    }
+    return a.length - b.length;
+  }
+  /**
+   * Check whether a value exposes a children array.
+   *
+   * @param {unknown} entity - Candidate value.
+   * @returns {boolean} True when entity has children array.
+   */
+  hasChildren(entity) {
+    return !!entity && Array.isArray(entity.children);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/helper/list-shift-tab-outdent-handler.js

@@ -0,0 +1,42 @@
+import { RTEListItemBlock } from '../../../../../dto/blocks/list-item-block';
+import { UnnestListItemsAction } from '../../../../../dto/actions/unnest-list-items-action';
+import { TransformParagraphAction } from '../../../../../dto/actions/transform-paragraph-action';
+import { VegaRTEContent } from '../../../../../dto/content-state';
+import { RTEHtmlBlock } from '../../../../../dto/blocks/html-block';
+import { AbstractListKeyboardHandler } from './abstract-list-keyboard-handler';
+/**
+ * Handles Shift+Tab key list outdent.
+ * Normalizes the selection, then promotes each segment, either moving nested
+ * items or promoting top-level items to paragraphs.
+ */
+export class ListShiftTabOutdentHandler extends AbstractListKeyboardHandler {
+  /**
+   * @inheritDoc
+   */
+  execute(selectedBlocks) {
+    const segments = this.normalizeToSegments(selectedBlocks);
+    if (!segments) {
+      return null;
+    }
+    const segmentSelectionBoundaries = new Array(segments.length).fill(null);
+    for (let i = segments.length - 1; i >= 0; i--) {
+      const segment = segments[i];
+      const parentList = segment[0].parent;
+      if (parentList.parent instanceof VegaRTEContent || parentList.parent instanceof RTEHtmlBlock) {
+        // Capture boundary before action moves text nodes into new paragraphs
+        const boundary = this.getSelectionBoundary(segment);
+        parentList.apply(new TransformParagraphAction(segment));
+        segmentSelectionBoundaries[i] = boundary;
+        continue;
+      }
+      if (parentList.parent instanceof RTEListItemBlock) {
+        parentList.apply(new UnnestListItemsAction(segment));
+        segmentSelectionBoundaries[i] = this.getSelectionBoundary(segment);
+      }
+    }
+    if (segmentSelectionBoundaries.some(Boolean)) {
+      return segmentSelectionBoundaries;
+    }
+    return null;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/helper/list-tab-indent-handler.js

@@ -0,0 +1,34 @@
+import { NestListItemsAction } from '../../../../../dto/actions/nest-list-items-action';
+import { AbstractListKeyboardHandler } from './abstract-list-keyboard-handler';
+/**
+ * Handles Tab key list indentation.
+ * Normalizes the selection, applies a command-style gate on the first
+ * eligible segment, then nests each qualifying segment.
+ */
+export class ListTabIndentHandler extends AbstractListKeyboardHandler {
+  /**
+   * @inheritDoc
+   */
+  execute(selectedBlocks) {
+    const segments = this.normalizeToSegments(selectedBlocks);
+    if (!segments) {
+      return null;
+    }
+    const firstSegment = segments[0];
+    const firstParentList = firstSegment[0].parent;
+    if (firstParentList.children.indexOf(firstSegment[0]) <= 0) {
+      return null;
+    }
+    const segmentSelectionBoundaries = new Array(segments.length).fill(null);
+    for (let i = segments.length - 1; i >= 0; i--) {
+      const segment = segments[i];
+      const parentList = segment[0].parent;
+      if (parentList.children.indexOf(segment[0]) <= 0) {
+        continue;
+      }
+      parentList.apply(new NestListItemsAction(segment));
+      segmentSelectionBoundaries[i] = this.getSelectionBoundary(segment);
+    }
+    return segmentSelectionBoundaries.some(Boolean) ? segmentSelectionBoundaries : null;
+  }
+}