@heartlandone/vega 2.94.0 → 2.96.0

package/dist/types/components/vega-combo-box/slimmers/renderers/vega-combo-box-dropdown-renderer.d.ts

@@ -15,6 +15,7 @@ export declare class VegaComboBoxDropdownRenderer extends VegaSlimmer {
   private useDefaultFilter;
   private createEventEmit;
   private searchEventEmit;
+  private selectAllClickEventEmit;
   private valueController;
   private sourceController;
   private isTemplateMode;

package/dist/types/components/vega-combo-box/vega-combo-box.d.ts

@@ -32,7 +32,9 @@ export declare class VegaComboBox {
   protected changeEventEmit: EventEmitSlimmerBase;
   protected createEventEmit: EventEmitSlimmerBase;
   protected searchEventEmit: EventEmitSlimmerBase;
+  protected selectAllClickEventEmit: EventEmitSlimmerBase;
   protected dropdownEventPrevent: ChildNodesEventPreventSlimmer;
+  protected dropdownEventPreventSelectAllClick: ChildNodesEventPreventSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaComboBoxElement>;
   host: HTMLVegaComboBoxElement;
   currentBreakpoint: BreakpointsTokenType;
@@ -205,6 +207,25 @@ export declare class VegaComboBox {
    * @vegaVersion 2.0.0
    */
   search: EventEmitter<string>;
+  /**
+   * An event emitter only fired when the Select All checkbox in the dropdown has been clicked.
+   *
+   * 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 only fired when the Select All checkbox in the dropdown has been clicked.
+   *
+   * 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
+   */
+  dropdownSelectAllClick: EventEmitter<boolean>;
   /**
    * Invoke this method to close the dropdown menu associated with the combo box.
    *

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-render-mode-controller.d.ts

@@ -7,7 +7,7 @@ import { VegaDropdown } from '../../vega-dropdown';
 export declare class VegaDropdownRenderModeController extends VegaSlimmer {
   host: VegaDropdown['host'];
   renderer: VegaDropdown['renderer'];
-  private renderMode;
+  renderMode: VegaDropdown['renderMode'];
   /**
    * The `connectedCallback` function is called before the component is rendered and is used to set the
    * render mode.
@@ -24,6 +24,7 @@ export declare class VegaDropdownRenderModeController extends VegaSlimmer {
    * While component first connected, the items slot is in the host.
    * While component connected after the first time, the items slot will apppend to vega-dropdown-content-box, so the parent changed.
    *   code: VegaDropdownRenderer.appendItemsToContentBox
+   *
    */
   private setRenderMode;
 }

package/dist/types/components/vega-dropdown/types.d.ts

@@ -1,8 +1,8 @@
 /**
  * Detail payload emitted by `vegaDropdownSelectAllClick` / `dropdownSelectAllClick`.
  *
- * `true` means all selectable items are now selected.
- * `false` means Select All has been cleared.
+ * `true` means the Select All checkbox was clicked to select all items.
+ * `false` means the Select All checkbox was clicked to clear all selected items.
  */
 export type VegaDropdownSelectAllClickEventDetail = boolean;
 

package/dist/types/components/vega-dropdown/vega-dropdown.d.ts

@@ -71,6 +71,7 @@ export declare class VegaDropdown {
   searchString: string;
   isDropdownShow: boolean;
   sourceForRender: VegaDropdownSourceItem[];
+  renderMode: 'SOURCE' | 'SLOT';
   watchIsDropdownShow(): void;
   /**
    * Specifies the size of the dropdown.
@@ -280,10 +281,33 @@ export declare class VegaDropdown {
    */
   searchTriggerBy: VegaDropdownSearchTriggerByType;
   /**
-   * 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
    */
   isScreenPosition: boolean;
@@ -340,19 +364,19 @@ export declare class VegaDropdown {
    */
   dropdownClick: EventEmitter<string>;
   /**
-   * An event emitter notifying that the Select All option has been clicked.
+   * An event emitter only fired when the Select All checkbox 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.93.0
    */
   vegaDropdownSelectAllClick: EventEmitter<boolean>;
   /**
-   * An event emitter notifying that the Select All option has been clicked.
+   * An event emitter only fired when the Select All checkbox 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.93.0
    */
@@ -520,5 +544,8 @@ export declare class VegaDropdown {
    * @vegaVersion 2.93.0
    */
   syncTemplateData(): Promise<void>;
+  /**
+   * Render the dropdown component.
+   */
   render(): VegaDropdown;
 }

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-dropdown-controller.d.ts

@@ -11,7 +11,9 @@ export declare class VegaInputSelectDropdownController extends VegaSlimmer {
   source: VegaInputSelect['source'];
   showEventEmitter: VegaInputSelect['showEventEmitter'];
   hideEventEmitter: VegaInputSelect['hideEventEmitter'];
+  vegaDropdownProps: VegaInputSelect['vegaDropdownProps'];
   selectType: VegaInputSelect['selectType'];
+  selectAllClickEventEmitter: VegaInputSelect['selectAllClickEventEmitter'];
   /** The `onDropdownShow` function is setting the `isDropdownShow` property of the`VegaInputSelectDropdownController` class to `true`. This function is called when the dropdown select input is shown. */
   onDropdownShow: () => void;
   /** The `onDropdownHide` function is setting the `isDropdownShow` property of the `VegaInputSelectDropdownController` class to `false`. This function is called when the dropdown select input is hidden. */

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-items-slot-controler.d.ts

@@ -5,6 +5,9 @@ import { MutationObserverSlimmer } from '../../../../helpers/slimmers/mutation-o
  * appending host items to a dropdown element.
  */
 export declare class VegaInputSelectItemsSlotController extends VegaSlimmer {
+  /**
+   * Observes the current template items container before and after relocation into the dropdown.
+   */
   protected mutationObserver: MutationObserverSlimmer;
   private host;
   private vegaInputSelectDropdownRenderer;
@@ -16,4 +19,11 @@ export declare class VegaInputSelectItemsSlotController extends VegaSlimmer {
    * The function appends host items to a dropdown element.
    */
   private appendHostItemsToDropdown;
+  /**
+   * Gets the template items container from host before relocation,
+   * or from dropdown after it has been moved.
+   *
+   * @returns {Nullable<HTMLElement>} The current template items container, if present.
+   */
+  private getItemsContainer;
 }

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

@@ -50,6 +50,7 @@ export type VegaDropdownPropsForSelect = Partial<
 		| 'itemDisplayRule'
 		| 'resettable'
 		| 'preserveValueIfNotInSource'
+		| 'allowSelectAll'
 	>
 >;
 

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

@@ -45,7 +45,9 @@ export declare class VegaInputSelect {
   protected showEventEmitter: EventEmitSlimmerBase;
   protected hideEventEmitter: EventEmitSlimmerBase;
   protected labelButtonClickEventEmitter: EventEmitSlimmerBase;
+  protected selectAllClickEventEmitter: EventEmitSlimmerBase;
   protected eventPrevent: ChildNodesEventPreventSlimmer;
+  protected dropdownEventPreventSelectAllClick: ChildNodesEventPreventSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaInputSelectElement>;
   host: HTMLVegaInputSelectElement;
   isDropdownShow: boolean;
@@ -266,6 +268,25 @@ export declare class VegaInputSelect {
    * @vegaVersion 2.30.0
    */
   searchTrigger: EventEmitter<VegaDropdownSearchTriggerEventDetail>;
+  /**
+   * An event emitter only fired when the Select All checkbox in the dropdown has been clicked.
+   *
+   * 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 only fired when the Select All checkbox in the dropdown has been clicked.
+   *
+   * 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
+   */
+  dropdownSelectAllClick: EventEmitter<boolean>;
   /**
    * An event emitter notifying that the input-select has been opened,
    *    either programmatically or via user interaction.

package/dist/types/components/vega-modal/slimmers/controllers/vega-modal-backdrop-manager.d.ts

@@ -0,0 +1,66 @@
+import { VegaModal } from '../../vega-modal';
+import { SharedBackdropManager } from '../../../../helpers/backdrop';
+/**
+ * Modal-specific backdrop manager — extends SharedBackdropManager to get its own static scope.
+ * Each subclass of SharedBackdropManager gets its own separate static state (consumers, visibility intents, etc).
+ * Handles backdrop color customization and stack-aware visibility.
+ */
+export declare class VegaModalBackdropManager extends SharedBackdropManager {
+  private static readonly modalBackdropClass;
+  private static visibleBackdropOwners;
+  private static readonly backdropColorMap;
+  host: VegaModal['host'];
+  backdrop: VegaModal['backdrop'];
+  backdropColor: VegaModal['backdropColor'];
+  openState: VegaModal['openState'];
+  /**
+   * Clear shared backdrop and ownership state.
+   */
+  clear(): void;
+  /**
+   * Watch backdrop property changes and update visibility intent.
+   */
+  watchBackdrop(): void;
+  /**
+   * Watch backdropColor property changes and update color if backdrop exists.
+   *
+   */
+  watchBackdropColor(): void;
+  /**
+   * Watch openState changes and update backdrop visibility intent.
+   */
+  watchOpenState(): void;
+  /**
+   * Opt in to lazy backdrop lifecycle: the DOM element is created on first show
+   * and removed when the last modal with a visible backdrop closes.
+   * This keeps `backdrop='none'` modals from leaving a stale DOM node.
+   *
+   * @returns {boolean} Always true for modals.
+   */
+  protected usesLazyBackdrop(): boolean;
+  /**
+   * Customize backdrop creation for modal use case with color support.
+   * Appends backdrop as a sibling of the modal host to share the same stacking context.
+   *
+   * @param {Document} doc - The document reference.
+   * @returns {HTMLVegaBackdropElement} The created and configured backdrop element.
+   */
+  protected createBackdrop(doc: Document): HTMLVegaBackdropElement;
+  /**
+   * Update this modal's backdrop intent.
+   */
+  private updateVisibility;
+  /**
+   * Keep a manager-ordered list of visible backdrop owners.
+   * The last owner in the list controls shared backdrop color.
+   *
+   * @param {boolean} shouldShow - Whether this manager currently requests a visible backdrop.
+   */
+  private trackBackdropOwner;
+  /**
+   * Apply color from the current active backdrop owner.
+   *
+   * @param {HTMLVegaBackdropElement} backdrop - Shared backdrop element.
+   */
+  private syncBackdropColor;
+}

package/dist/types/components/vega-modal/slimmers/controllers/vega-modal-open-state-controller.d.ts

@@ -14,7 +14,7 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
   handleClose: VegaModal['handleClose'];
   closeEventEmitter: VegaModal['closeEventEmitter'];
   openEventEmitter: VegaModal['openEventEmitter'];
-  backdropController: VegaModal['backdropController'];
+  backdropManager: VegaModal['backdropManager'];
   openedModalStackController: VegaModal['openedModalStackController'];
   zIndexController: VegaModal['zIndexController'];
   renderer: VegaModal['renderer'];
@@ -113,10 +113,6 @@ export declare class VegaModalOpenStateController extends VegaSlimmer {
    * In desktop, we should add 'overflow: hidden' to the body to prevent the body scroll.
    */
   private updateDocumentRootOverflow;
-  /**
-   * Removes the backdrop element if no modals are currently visible.
-   */
-  private removeBackdropWhileNoModalShow;
   /**
    * Check if mouse event originates from vega-modal backdrop.
    *

package/dist/types/components/vega-modal/slimmers/controllers/vega-modal-z-index-controller.d.ts

@@ -7,7 +7,7 @@ export declare class VegaModalZIndexController extends VegaSlimmer {
   host: VegaModal['host'];
   open: VegaModal['open'];
   openState: VegaModal['openState'];
-  backdropController: VegaModal['backdropController'];
+  backdropManager: VegaModal['backdropManager'];
   openedModalStackController: VegaModal['openedModalStackController'];
   /**
    * Manages the z-index of modal elements based on their visibility status.

package/dist/types/components/vega-modal/slimmers/renderers/vega-modal-renderer.d.ts

@@ -10,7 +10,7 @@ export declare class VegaModalRenderer extends VegaSlimmer {
   openState: VegaModal['openState'];
   padding: VegaModal['padding'];
   margin: VegaModal['margin'];
-  size: VegaModal['size'];
+  sizeDeprecatedPropertySlimmer: VegaModal['sizeDeprecatedPropertySlimmer'];
   height: VegaModal['height'];
   corners: VegaModal['corners'];
   showCloseButton: VegaModal['showCloseButton'];

package/dist/types/components/vega-modal/vega-modal.d.ts

@@ -13,7 +13,7 @@ import { VegaModalRenderer } from './slimmers/renderers/vega-modal-renderer';
 import { VegaModalMobileController } from './slimmers/controllers/vega-modal-mobile-controller';
 import { VegaModalScrollController } from './slimmers/controllers/vega-modal-scroll-controller';
 import { VegaModalOpenStateController } from './slimmers/controllers/vega-modal-open-state-controller';
-import { VegaModalBackdropController } from './slimmers/controllers/vega-modal-backdrop-controller';
+import { VegaModalBackdropManager } from './slimmers/controllers/vega-modal-backdrop-manager';
 import { VegaModalOpenedModalStackController } from './slimmers/controllers/vega-modal-opened-modal-stack-controller';
 import { VegaModalZIndexController } from './slimmers/controllers/vega-modal-z-index-controller';
 import { VegaModalOpenState } from './slimmers/models/vega-modal-open-state';
@@ -28,7 +28,7 @@ export declare class VegaModal {
   protected readonly openStateController: VegaModalOpenStateController;
   protected readonly mobileController: VegaModalMobileController;
   protected readonly scrollController: VegaModalScrollController;
-  protected readonly backdropController: VegaModalBackdropController;
+  protected readonly backdropManager: VegaModalBackdropManager;
   protected readonly openedModalStackController: VegaModalOpenedModalStackController;
   protected readonly zIndexController: VegaModalZIndexController;
   protected readonly paddingStateController: VegaModalPaddingStateController;
@@ -38,6 +38,7 @@ export declare class VegaModal {
   protected childNodesEventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly componentGlobalStyleSlimmer: ComponentGlobalStyleSlimmer<HTMLVegaModalElement>;
   protected readonly deprecatedPropertySlimmer: DeprecatedPropertySlimmerBase<boolean>;
+  protected readonly sizeDeprecatedPropertySlimmer: DeprecatedPropertySlimmerBase<ResponsiveType<SizeType>>;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaModalElement>;
   host: HTMLVegaModalElement;
   currentBreakpoint: BreakpointsTokenType;
@@ -55,13 +56,14 @@ export declare class VegaModal {
    * - `none`:
    *      specifies that the backdrop will not be rendered.
    *
-   * _Note_:
-   *    When changing this value, a page refresh is required
-   *    for the changes to take effect.
-   *
    * @vegaVersion 1.0.6
    */
   backdrop: VegaModalBackdrop;
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-modal-default-e2e}
+   */
+  watchBackdrop(): void;
   /**
    * Determines the size of the modal.
    *
@@ -72,6 +74,7 @@ export declare class VegaModal {
    *    for modal windows based on the viewport size. If the specified size exceeds
    *    the maximum width, the maximum modal width will be used instead.
    *
+   * @deprecated This property will be removed soon and replaced by prop width
    * @vegaVersion 1.0.6
    */
   size: ResponsiveType<SizeType>;
@@ -81,6 +84,24 @@ export declare class VegaModal {
    * @see{module:vega-modal-size-responsive-e2e}
    */
   watchSize(): void;
+  /**
+   * Determines the width of the modal.
+   *
+   * It can be specified as a number or a percentage string ending with "%".
+   * ResponsiveType can also be used for responsive configurations.
+   *
+   * Note: There are different maximum widths for modal windows based on viewport size.
+   * If the specified width exceeds the maximum width, the maximum modal width will be used instead.
+   *
+   * @vegaVersion 2.95.0
+   */
+  width: ResponsiveType<SizeType>;
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-modal-width-number-e2e}
+   * @see{module:vega-modal-width-responsive-e2e}
+   */
+  watchWidth(): void;
   /**
    * Determines the height of the modal.
    *
@@ -121,6 +142,13 @@ export declare class VegaModal {
    * @vegaVersion 1.3.0
    */
   backdropColor: VegaModalBackdropColor;
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-modal-backdrop-color-default-e2e}
+   * @see{module:vega-modal-backdrop-color-semi-e2e}
+   * @see{module:vega-modal-backdrop-color-none-e2e}
+   */
+  watchBackdropColor(): void;
   /**
    * Determines whether the modal is vertically centered
    *    on the screen.

package/dist/types/components/vega-progress-tracker/slimmers/controllers/vega-progress-tracker-current-steps-controller.d.ts

@@ -28,6 +28,8 @@ export declare class VegaProgressTrackerCurrentStepsController extends VegaSlimm
   watchCompletedStepArray(): void;
   /** while completedSteps changed, we need sync up current steps */
   watchCompletedSteps(): void;
+  /** while canClickStep changed, we need sync up current steps */
+  watchCanClickStep(): void;
   /**
    * Sync up current steps
    */

package/dist/types/components/vega-progress-tracker/vega-progress-tracker.d.ts

@@ -95,6 +95,7 @@ export declare class VegaProgressTracker {
    * @vegaVersion 1.5.0
    */
   canClickStep: boolean;
+  watchCanClickStep(): void;
   /**
    * When enabled, `current = -1` becomes a valid state that indicates
    *    no highlighted/current step (e.g. all steps are pending or the

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;
 }