@heartlandone/vega 2.95.0 → 2.96.0

package/dist/types/components/vega-input-select/vega-input-select.d.ts

@@ -269,19 +269,19 @@ export declare class VegaInputSelect {
    */
   searchTrigger: EventEmitter<VegaDropdownSearchTriggerEventDetail>;
   /**
-   * An event emitter notifying that the Select All option in the dropdown has been clicked.
+   * An event emitter only fired when the Select All checkbox in the dropdown has been clicked.
    *
-   * The event's `detail` property is `true` when all items become selected,
-   * and `false` when Select All is cleared.
+   * The event's `detail` property is `true` when the Select All checkbox is clicked to select all items,
+   *    and `false` when the Select All checkbox is clicked to clear all selected items.
    *
    * @vegaVersion 2.95.0
    */
   vegaDropdownSelectAllClick: EventEmitter<boolean>;
   /**
-   * An event emitter notifying that the Select All option in the dropdown has been clicked.
+   * An event emitter only fired when the Select All checkbox in the dropdown has been clicked.
    *
-   * The event's `detail` property is `true` when all items become selected,
-   * and `false` when Select All is cleared.
+   * The event's `detail` property is `true` when the Select All checkbox is clicked to select all items,
+   *    and `false` when the Select All checkbox is clicked to clear all selected items.
    *
    * @eventSemantics namespace:native
    * @vegaVersion 2.95.0

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

@@ -0,0 +1,36 @@
+import { ModifyContentAction } from '../../actions/modify-content-action.abstract';
+import { RTEBlock } from '../../blocks/block.abstract';
+import { RTEListBlock } from '../../blocks/list-block';
+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 declare abstract class ListAnnotationStrategy<T extends ModifyContentAction, Target extends RTEBlock> extends ActionHandleStrategy<T, Target> {
+  /**
+   * 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.
+   */
+  protected copyListAnnotations(source: RTEListBlock, target: RTEListBlock): void;
+  /**
+   * 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.
+   */
+  protected haveSameListAnnotations(first: RTEListBlock, second: RTEListBlock): boolean;
+  /**
+   * Recursively sort object keys for stable annotation comparison.
+   *
+   * @param {unknown} value - Annotation value to normalize.
+   * @returns {unknown} Normalized annotation value.
+   */
+  private normalizeAnnotationValue;
+}

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

@@ -1,12 +1,24 @@
 import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
 import type { RTEListItemBlock } from '../../blocks/list-item-block';
-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 declare class ListItemReplaceNestListStrategy extends ActionHandleStrategy<ReplaceNestListAction, RTEListItemBlock> {
+export declare class ListItemReplaceNestListStrategy extends ListAnnotationStrategy<ReplaceNestListAction, RTEListItemBlock> {
   /**
    * @inheritDoc
    */
   protected handleAction(action: ReplaceNestListAction, target: RTEListItemBlock): void;
+  /**
+   * 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.
+   */
+  private mergeAdjacentSameType;
 }

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

@@ -0,0 +1,22 @@
+import { NestListItemsAction } from '../../actions/nest-list-items-action';
+import { UnnestListItemsAction } from '../../actions/unnest-list-items-action';
+import { RTEListBlock } from '../../blocks/list-block';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+declare type ListItemsSelectionAction = NestListItemsAction | UnnestListItemsAction;
+/**
+ * Shared base strategy for list-item operations that require ordered contiguous
+ * item selection within the same target list.
+ */
+export declare abstract class AbstractListItemsStrategy<T extends ListItemsSelectionAction, R = void> extends ActionHandleStrategy<T, RTEListBlock, R> {
+  /**
+   * 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.
+   */
+  protected getOrderedContiguousItems(target: RTEListBlock, selectedBlocks: RTEListItemBlock[]): RTEListItemBlock[];
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { NestListItemsAction } from '../../actions/nest-list-items-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 declare class ListNestItemsStrategy extends AbstractListItemsStrategy<NestListItemsAction> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: NestListItemsAction, target: RTEListBlock): void;
+  /**
+   * 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.
+   */
+  private unifyDescendantNestLists;
+}

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

@@ -12,4 +12,18 @@ export declare class ListRemoveListItemStrategy extends RemoveChildrenStrategy {
    * @param {RTEListBlock} target - The list block.
    */
   protected handleAction(action: RemoveChildrenAction, target: RTEListBlock): void;
+  /**
+   * 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.
+   */
+  private promoteNestListsToUpperLevel;
 }

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-transform-selection.d.ts

@@ -0,0 +1,15 @@
+import { ListType } from '../../../interface';
+import { RTEBlock } from '../../blocks/block.abstract';
+/**
+ * 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 declare function normalizeMixedListSelection(selectedBlocks: RTEBlock[], listType: ListType): RTEBlock[];

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-transform-to-list-strategy.d.ts

@@ -1,12 +1,39 @@
 import { TransformListAction } from '../../actions/transform-list-action';
-import type { RTEListBlock } from '../../blocks/list-block';
-import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { RTEListBlock } from '../../blocks/list-block';
+import { ListAnnotationStrategy } from './list-annotation-strategy.abstract';
 /**
  * Convert the selected blocks to list strategy.
  */
-export declare class ListTransformToListStrategy extends ActionHandleStrategy<TransformListAction, RTEListBlock> {
+export declare class ListTransformToListStrategy extends ListAnnotationStrategy<TransformListAction, RTEListBlock> {
   /**
    * @inheritDoc
    */
   protected handleAction(action: TransformListAction, target: RTEListBlock): void;
+  /**
+   * Convert a single list's type in place, preserving its items and their nested
+   * structure. Root lists are swapped in the content children; nested lists are
+   * swapped inside their parent item's nestList.
+   *
+   * @param {RTEListBlock} list - The list whose type should be converted.
+   * @param {RTEListBlock['type']} listType - The target list type.
+   */
+  private convertListTypeInPlace;
+  /**
+   * Handle the case where selected blocks span multiple nestLists under the same parent item.
+   * Transform each affected list and then merge adjacent same-type lists.
+   *
+   * @param {TransformListAction} action - The transform action with selection and target list type.
+   * @param {RTEListBlock} target - The nested list where transformation starts.
+   */
+  private handleCrossListTransform;
+  /**
+   * Create a replacement list through the owning content factory while retaining
+   * the source list's container annotations.
+   *
+   * @param {VegaRTEContent} rootContent - Editor content owning the factory.
+   * @param {RTEListBlock} source - List whose annotations should be retained.
+   * @param {RTEListBlock['type']} listType - Replacement list type.
+   * @returns {RTEListBlock} New annotated list shell.
+   */
+  private createListFromSource;
 }

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-transform-to-paragraph-strategy.d.ts

@@ -1,14 +1,110 @@
 import { TransformParagraphAction } from '../../actions/transform-paragraph-action';
-import type { RTEListBlock } from '../../blocks/list-block';
-import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+import { RTEListBlock } from '../../blocks/list-block';
+import { ListAnnotationStrategy } from './list-annotation-strategy.abstract';
 /**
  * Convert the selected list block to paragraph strategy.
  */
-export declare class ListTransformToParagraphStrategy extends ActionHandleStrategy<TransformParagraphAction, RTEListBlock> {
+export declare class ListTransformToParagraphStrategy extends ListAnnotationStrategy<TransformParagraphAction, RTEListBlock> {
   /**
    * @inheritDoc
    */
   protected handleAction(action: TransformParagraphAction, target: RTEListBlock): void;
+  /**
+   * Ensure the action is applied to the first selected item's parent list and
+   * every selected item belongs to the same editor content.
+   *
+   * @param {RTEListItemBlock[][]} selectedSegments - Normalized selection segments.
+   * @param {RTEListBlock} target - List receiving the transform action.
+   * @returns {boolean} Whether the target and root content are consistent.
+   */
+  private hasConsistentTargetAndRoot;
+  /**
+   * Capture selected text nodes in document order before reverse-order tree
+   * mutations move them into paragraphs.
+   *
+   * @param {RTEListItemBlock[][]} selectedSegments - Normalized selection segments.
+   */
+  private syncSelection;
+  /**
+   * Transform one normalized segment without recursively dispatching another
+   * flushable action.
+   *
+   * @param {RTEListItemBlock[]} segment - Contiguous items sharing one parent list.
+   */
+  private transformSegment;
+  /**
+   * Handle the case where the target list is at root level (parent is VegaRTEContent).
+   *
+   * @param {TransformParagraphAction} action - The paragraph transform action.
+   * @param {RTEListBlock} target - The root list being transformed.
+   */
+  private handleRootListCase;
+  /**
+   * Handle the case where the target list is nested (parent is RTEListItemBlock).
+   *
+   * Algorithm:
+   * 1. Build the ancestor path from root list down to the target nested list.
+   * 2. At each level on the path, collect "trailing" items (items after the ancestor).
+   * 3. Trim each list along the path to keep only the "before" portion.
+   * 4. Collect trailing items from all levels + selected item's own nestList children.
+   * 5. Group trailing items into lists by consecutive type.
+   * 6. Insert into content: [before-root-list, paragraphs, ...after-lists].
+   *
+   * @param {TransformParagraphAction} action - The paragraph transform action.
+   * @param {RTEListBlock} target - The nested list being transformed.
+   */
+  private handleNestedListCase;
+  /**
+   * Normalize selected items into document order and split them into contiguous
+   * segments that share the same immediate parent list. Unlike Shift+Tab, the
+   * toolbar action keeps selected descendants so every selected item becomes a
+   * paragraph.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Raw selected blocks.
+   * @returns {RTEListItemBlock[][]} Parent-based contiguous selection segments.
+   */
+  private getSelectedSegments;
+  /**
+   * Resolve a list item's structural document path, including the positions of
+   * root lists, owning list items, nested lists, and the item itself.
+   *
+   * @param {RTEListItemBlock} item - Selected list item.
+   * @returns {number[] | null} Structural path, or null for a detached item.
+   */
+  private getStructuralPath;
+  /**
+   * Resolve a root list's path through zero or more HTML containers to the
+   * editor content.
+   *
+   * @param {RTEListBlock} rootList - List whose parent is a content container.
+   * @returns {number[] | null} Container path, or null for detached/cyclic ownership.
+   */
+  private getContainerPath;
+  /**
+   * Compare two structural paths in document order.
+   *
+   * @param {number[]} firstPath - First structural path.
+   * @param {number[]} secondPath - Second structural path.
+   * @returns {number} Relative document order.
+   */
+  private compareStructuralPaths;
+  /**
+   * Append a list to an operation-local block sequence, merging only with the
+   * immediately preceding same-type list in that sequence.
+   *
+   * @param {RTEBlock[]} blocks - Operation-local output sequence.
+   * @param {RTEListBlock} list - List to append or merge.
+   */
+  private appendListBlock;
+  /**
+   * Create a list through the content factory and retain the source list's
+   * container annotations when a structural split requires a new list block.
+   *
+   * @param {VegaRTEContent} rootContent - Editor content that owns the factory.
+   * @param {RTEListBlock} source - List whose type and annotations should be retained.
+   * @returns {RTEListBlock} Newly created list shell.
+   */
+  private createListFromSource;
   /**
    * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
    *

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/list-unnest-items-strategy.d.ts

@@ -0,0 +1,22 @@
+import { UnnestListItemsAction } from '../../actions/unnest-list-items-action';
+import { RTEListBlock } from '../../blocks/list-block';
+import { AbstractListItemsStrategy } from './list-items-strategy.abstract';
+/**
+ * Promote selected nested list items one level up.
+ */
+export declare class ListUnnestItemsStrategy extends AbstractListItemsStrategy<UnnestListItemsAction> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: UnnestListItemsAction, target: RTEListBlock): void;
+  /**
+   * Collect and remove nestList entries that appear after the given target list
+   * in the parent item's nestList array. These trailing entries need to be
+   * transferred to the unnested item to preserve visual document order.
+   *
+   * @param {RTEListItemBlock} parentListItem - The list item owning the nestList.
+   * @param {RTEListBlock} target - The list being removed (used as the reference point).
+   * @returns {RTEListBlock[]} The trailing nestList entries (already removed from parentListItem).
+   */
+  private collectTrailingNestLists;
+}

package/dist/types/components/vega-rich-text-editor/dto/actions/modify-content-action.abstract.d.ts

@@ -15,6 +15,8 @@ export declare enum ModifyContentActionType {
   'LINE_BREAK_MULTIPLE_BLOCKS' = "LINE_BREAK_MULTIPLE_BLOCKS",
   'TRANSFORM_LIST_BLOCK' = "TRANSFORM_LIST_BLOCK",
   'TRANSFORM_PARAGRAPH_BLOCK' = "TRANSFORM_PARAGRAPH_BLOCK",
+  'NEST_LIST_ITEMS' = "NEST_LIST_ITEMS",
+  'UNNEST_LIST_ITEMS' = "UNNEST_LIST_ITEMS",
   'DELETE_BLOCK_CONTENT' = "DELETE_BLOCK_CONTENT",
   'INSERT_IMAGE_TO_BLOCK' = "INSERT_IMAGE_TO_BLOCK",
   'UPDATE_IMAGE_NODE_URL' = "UPDATE_IMAGE_NODE_URL",

package/dist/types/components/vega-rich-text-editor/dto/actions/nest-list-items-action.d.ts

@@ -0,0 +1,11 @@
+import { RTEListItemBlock } from '../blocks/list-item-block';
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Action to nest the selected list items under the previous sibling.
+ */
+export declare class NestListItemsAction extends ModifyContentAction {
+  readonly type: ModifyContentActionType;
+  isFlushable: boolean;
+  selectedBlocks: RTEListItemBlock[];
+  constructor(selectedBlocks: RTEListItemBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/dto/actions/unnest-list-items-action.d.ts

@@ -0,0 +1,11 @@
+import { RTEListItemBlock } from '../blocks/list-item-block';
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Action to promote the selected nested list items one level up.
+ */
+export declare class UnnestListItemsAction extends ModifyContentAction {
+  readonly type: ModifyContentActionType;
+  isFlushable: boolean;
+  selectedBlocks: RTEListItemBlock[];
+  constructor(selectedBlocks: RTEListItemBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/dto/annotations/list-annotation.d.ts

@@ -12,6 +12,14 @@ export declare class ListAnnotation extends BlockAnnotation {
    * @returns {AnnotationStyle} The default styles.
    */
   static getDefaultStyles(): AnnotationStyle;
+  /**
+   * Get the default standalone styles for a list block's item marker
+   * (`li::marker`). Capping the marker font-size keeps bullets/numbers
+   * at a normal size when list items are styled as title/subtitle.
+   *
+   * @returns {AnnotationStyle} The default marker styles.
+   */
+  static getDefaultMarkerStyles(): AnnotationStyle;
   /**
    * @inheritDoc
    */

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-block.d.ts

@@ -7,7 +7,12 @@ import { Nullable } from '../../../../types/general';
 import { RTEHtmlBlock } from './html-block';
 export declare type RTEListBlockTagType = 'ol' | 'ul';
 /**
- * List block
+ * List block.
+ *
+ * Bidirectional nesting contract:
+ * - Every child list item must have item.parent === this list block.
+ * - If this list block is nested, its parent must be a list item and that
+ *   list item keeps this block in listItem.nestList.
  */
 export declare class RTEListBlock extends RTEBlock<VegaRTEContent | RTEListItemBlock | RTEHtmlBlock, RTEListItemBlock> {
   static readonly dtoName: string;

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-item-block.d.ts

@@ -3,7 +3,11 @@ import { RTETextNode } from '../nodes/text-node';
 import { RTEListBlock } from './list-block';
 import { RTETextBlock } from './text-block';
 /**
- * List item block
+ * List item block.
+ *
+ * Bidirectional nesting contract:
+ * - nestList stores nested list blocks owned by this list item.
+ * - Every nested list block must have listBlock.parent === this list item.
  */
 export declare class RTEListItemBlock extends RTETextBlock {
   static readonly dtoName: string;

package/dist/types/components/vega-rich-text-editor/dto/content-state.d.ts

@@ -86,10 +86,10 @@ export declare 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: RTETextBlock): RTEListItemBlock;
+  toListItem(block: RTETextBlock | RTEListItemBlock): RTEListItemBlock;
   /**
    * create list.
    *

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/list-block-renderer.d.ts

@@ -3,6 +3,8 @@ import { RTEListBlock } from '../../blocks/list-block';
 import { RTERenderContext } from '../../../interface';
 declare class RTEListBlockRenderer extends RTEBlockRenderer {
   render(block: RTEListBlock, renderContext: RTERenderContext): HTMLElement;
+  private resolveListMarker;
+  private getListDepth;
 }
 declare const _default: RTEListBlockRenderer;
 export default _default;

package/dist/types/components/vega-rich-text-editor/dto/renderers/blocks/list-item-block-renderer.d.ts

@@ -3,6 +3,14 @@ import { RTERenderContext } from '../../../interface';
 import { RTEBlockTextNodesRenderer } from './block-text-nodes-renderer.abstract';
 declare class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
   render(block: RTEListItemBlock, renderContext: RTERenderContext): HTMLElement;
+  /**
+   * 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.
+   */
+  private getRenderKey;
   private renderChildren;
 }
 declare const _default: RTEListItemBlockRenderer;

package/dist/types/components/vega-rich-text-editor/extensions/table/annotation-handler/table-annotation-handler-base.d.ts

@@ -5,6 +5,13 @@ import { VegaRTETableBorderType } from '../annotations/table-annotation';
  * Base class for table annotation handlers with common extraction methods.
  */
 export declare abstract class TableAnnotationHandlerBase extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * 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.
+   */
+  private static readonly BORDER_WIDTH_KEYWORDS;
   /**
    * Extract background color from element.
    *
@@ -19,6 +26,17 @@ export declare abstract class TableAnnotationHandlerBase extends AnnotationGener
    * @returns {Nullable<VegaRTETableBorderType>} Border properties.
    */
   protected getBorder(element: HTMLElement): Nullable<VegaRTETableBorderType>;
+  /**
+   * 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).
+   */
+  protected normalizeBorderWidth(borderWidth: string): string;
   /**
    * Extract width from element.
    *

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/bullets-numbers/bullets-numbers-toolbar-button-slimmer.d.ts

@@ -1,13 +1,21 @@
 import { ToolbarInternalButtonConfig } from '../toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../../vega-rich-text-editor';
+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';
 export declare class BulletsNumbersToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
   protected readonly selectionController: VegaRichTextEditor['selectionController'];
+  protected readonly valueController: VegaRichTextEditor['valueController'];
+  protected readonly value: VegaRichTextEditor['value'];
+  protected readonly toolbarItems: VegaRichTextEditor['toolbarItems'];
+  protected readonly vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
   protected readonly bulletsToolbarButtonSlimmer: BulletsToolbarButtonSlimmer;
   protected readonly numbersToolbarButtonSlimmer: NumbersToolbarButtonSlimmer;
+  protected readonly listKeyboardSlimmer: ListKeyboardSlimmer;
   protected popoverRef: HTMLVegaPopoverElement;
+  disconnectedCallback(): void;
+  componentDidLoad(): void;
   componentWillRender(): void;
   constructor();
   protected renderBtnWrapper(renderBtn: (toolbarInternalButton: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;

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

@@ -0,0 +1,99 @@
+import { Nullable } from '../../../../../../../types/general';
+import { RTEBlock } from '../../../../../dto/blocks/block.abstract';
+import { RTEListItemBlock } from '../../../../../dto/blocks/list-item-block';
+import { RTETextNode } from '../../../../../dto/nodes/text-node';
+/**
+ * Abstract base for list keyboard (Tab / Shift+Tab) handlers.
+ * Provides shared selection-normalization utilities used by both the indent
+ * and outdent concrete handlers.
+ */
+export declare abstract 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.
+   */
+  protected getOutdentRoots(selection: RTEListItemBlock[]): RTEListItemBlock[];
+  /**
+   * 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.
+   */
+  protected hasSelectedAncestor(item: RTEListItemBlock, selectedItems: Set<RTEListItemBlock>): boolean;
+  /**
+   * 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.
+   */
+  protected splitSelectionIntoParentSegments(selection: RTEListItemBlock[]): RTEListItemBlock[][];
+  /**
+   * 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.
+   */
+  protected normalizeToSegments(selectedBlocks: RTEBlock[]): RTEListItemBlock[][] | 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.
+   */
+  protected getSelectionBoundary(blocks: RTEBlock[]): Nullable<[RTETextNode, RTETextNode]>;
+  /**
+   * 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.
+   */
+  protected getOrderedListItems(selectedBlocks: RTEBlock[]): RTEListItemBlock[] | null;
+  /**
+   * 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.
+   */
+  protected getSelectedListItemsUntilFirstNonList(selectedBlocks: RTEBlock[]): RTEListItemBlock[];
+  /**
+   * 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.
+   */
+  protected getTreePath(item: RTEListItemBlock): number[];
+  /**
+   * 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.
+   */
+  protected compareTreePath(a: number[], b: number[]): number;
+  /**
+   * Check whether a value exposes a children array.
+   *
+   * @param {unknown} entity - Candidate value.
+   * @returns {boolean} True when entity has children array.
+   */
+  protected hasChildren(entity: unknown): entity is {
+    children: unknown[];
+  };
+  /**
+   * Execute the keyboard action for the given selection and return the
+   * resulting selection boundaries, or null when no action was taken.
+   *
+   * @param {RTEBlock[]} selectedBlocks - Currently selected blocks.
+   * @returns {Array<Nullable<[RTETextNode, RTETextNode]>> | null} Selection boundaries after action.
+   */
+  abstract execute(selectedBlocks: RTEBlock[]): Array<Nullable<[RTETextNode, RTETextNode]>> | null;
+}

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

@@ -0,0 +1,15 @@
+import { Nullable } from '../../../../../../../types/general';
+import { RTEBlock } from '../../../../../dto/blocks/block.abstract';
+import { RTETextNode } from '../../../../../dto/nodes/text-node';
+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 declare class ListShiftTabOutdentHandler extends AbstractListKeyboardHandler {
+  /**
+   * @inheritDoc
+   */
+  execute(selectedBlocks: RTEBlock[]): Array<Nullable<[RTETextNode, RTETextNode]>> | null;
+}