@heartlandone/vega 2.95.0 → 2.96.0

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

@@ -0,0 +1,104 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { SyncUpSelectionAction } from '../../actions/sync-up-selection-action';
+import { RemoveNestListAction } from '../../actions/remove-nest-list-action';
+import { ReplaceNestListAction } from '../../actions/replace-nest-list-action';
+import { RTEListBlock } from '../../blocks/list-block';
+import { RTEListItemBlock } from '../../blocks/list-item-block';
+import { AbstractListItemsStrategy } from './list-items-strategy.abstract';
+/**
+ * Promote selected nested list items one level up.
+ */
+export class ListUnnestItemsStrategy extends AbstractListItemsStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    var _a;
+    const selectedItems = this.getOrderedContiguousItems(target, action.selectedBlocks);
+    const parentListParent = target.parent;
+    if (!selectedItems.length || !(parentListParent instanceof RTEListItemBlock)) {
+      return;
+    }
+    const selectedStartIndex = target.children.indexOf(selectedItems[0]);
+    const selectedEndIndex = target.children.indexOf(selectedItems[selectedItems.length - 1]);
+    if (selectedStartIndex < 0 || selectedEndIndex < selectedStartIndex) {
+      return;
+    }
+    const parentListItem = parentListParent;
+    const grandParentList = parentListItem.parent;
+    const insertAfterIndex = grandParentList.children.indexOf(parentListItem);
+    if (insertAfterIndex < 0) {
+      return;
+    }
+    const trailingSiblingItems = target.children.slice(selectedEndIndex + 1);
+    const selectedItemSet = new Set(selectedItems);
+    target.children = target.children.filter((item) => !selectedItemSet.has(item));
+    grandParentList.children = [
+      ...grandParentList.children.slice(0, insertAfterIndex + 1),
+      ...selectedItems,
+      ...grandParentList.children.slice(insertAfterIndex + 1),
+    ];
+    selectedItems.forEach((item) => {
+      item.parent = grandParentList;
+      item.children.forEach((node) => node.apply(new SyncUpSelectionAction()));
+    });
+    if (trailingSiblingItems.length > 0) {
+      const trailingSiblingSet = new Set(trailingSiblingItems);
+      target.children = target.children.filter((item) => !trailingSiblingSet.has(item));
+      const newParentItem = selectedItems[selectedItems.length - 1];
+      let nestedList = (_a = newParentItem.nestList) === null || _a === void 0 ? void 0 : _a[newParentItem.nestList.length - 1];
+      // Shift+Tab follows same-type guard: when the last nested list has a
+      // different type, create a new child list of target.type instead of merging.
+      if (nestedList && nestedList.type !== target.type) {
+        nestedList = null;
+      }
+      if (!nestedList) {
+        nestedList = new RTEListBlock(generateUUID(), target.type);
+        const existingNestLists = Array.isArray(newParentItem.nestList)
+          ? newParentItem.nestList
+          : [];
+        newParentItem.apply(new ReplaceNestListAction([...existingNestLists, nestedList]));
+      }
+      nestedList.children = nestedList.children.concat(trailingSiblingItems);
+      trailingSiblingItems.forEach((item) => {
+        item.parent = nestedList;
+      });
+    }
+    // Lists after target are visually after every target item. Once selected items
+    // move above their former parent, transfer those later branches to the last
+    // selected item even when target still contains leading items; otherwise the
+    // branches render before the promoted selection and document order changes.
+    const trailingNestLists = this.collectTrailingNestLists(parentListItem, target);
+    if (trailingNestLists.length > 0) {
+      const lastSelected = selectedItems[selectedItems.length - 1];
+      const existingNest = Array.isArray(lastSelected.nestList)
+        ? lastSelected.nestList
+        : [];
+      lastSelected.apply(new ReplaceNestListAction([...existingNest, ...trailingNestLists]));
+    }
+    if (target.children.length === 0) {
+      parentListItem.apply(new RemoveNestListAction(target));
+    }
+  }
+  /**
+   * 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).
+   */
+  collectTrailingNestLists(parentListItem, target) {
+    var _a;
+    const nestLists = (_a = parentListItem.nestList) !== null && _a !== void 0 ? _a : [];
+    const targetIndex = nestLists.indexOf(target);
+    if (targetIndex < 0 || targetIndex >= nestLists.length - 1) {
+      return [];
+    }
+    const trailing = nestLists.slice(targetIndex + 1);
+    // Keep only entries up to and including target (target will be removed separately).
+    parentListItem.apply(new ReplaceNestListAction(nestLists.slice(0, targetIndex + 1)));
+    return trailing;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/modify-content-action.abstract.js

@@ -16,6 +16,8 @@ export var ModifyContentActionType;
   ModifyContentActionType["LINE_BREAK_MULTIPLE_BLOCKS"] = "LINE_BREAK_MULTIPLE_BLOCKS";
   ModifyContentActionType["TRANSFORM_LIST_BLOCK"] = "TRANSFORM_LIST_BLOCK";
   ModifyContentActionType["TRANSFORM_PARAGRAPH_BLOCK"] = "TRANSFORM_PARAGRAPH_BLOCK";
+  ModifyContentActionType["NEST_LIST_ITEMS"] = "NEST_LIST_ITEMS";
+  ModifyContentActionType["UNNEST_LIST_ITEMS"] = "UNNEST_LIST_ITEMS";
   ModifyContentActionType["DELETE_BLOCK_CONTENT"] = "DELETE_BLOCK_CONTENT";
   ModifyContentActionType["INSERT_IMAGE_TO_BLOCK"] = "INSERT_IMAGE_TO_BLOCK";
   ModifyContentActionType["UPDATE_IMAGE_NODE_URL"] = "UPDATE_IMAGE_NODE_URL";

package/dist/collection/components/vega-rich-text-editor/dto/actions/nest-list-items-action.js

@@ -0,0 +1,12 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Action to nest the selected list items under the previous sibling.
+ */
+export class NestListItemsAction extends ModifyContentAction {
+  constructor(selectedBlocks) {
+    super();
+    this.type = ModifyContentActionType.NEST_LIST_ITEMS;
+    this.isFlushable = true;
+    this.selectedBlocks = selectedBlocks;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/actions/unnest-list-items-action.js

@@ -0,0 +1,12 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Action to promote the selected nested list items one level up.
+ */
+export class UnnestListItemsAction extends ModifyContentAction {
+  constructor(selectedBlocks) {
+    super();
+    this.type = ModifyContentActionType.UNNEST_LIST_ITEMS;
+    this.isFlushable = true;
+    this.selectedBlocks = selectedBlocks;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/list-annotation.js

@@ -18,6 +18,18 @@ export class ListAnnotation extends BlockAnnotation {
       marginLeft: '16px',
     };
   }
+  /**
+   * 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() {
+    return {
+      fontSize: '16px',
+    };
+  }
   /**
    * @inheritDoc
    */

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

@@ -5,6 +5,8 @@ import { ActionHandleStrategyRegistry } from '../action-handle-strategies/action
 import { ListTransformToListStrategy } from '../action-handle-strategies/modify-content-strategies/list-transform-to-list-strategy';
 import { ListTransformToParagraphStrategy } from '../action-handle-strategies/modify-content-strategies/list-transform-to-paragraph-strategy';
 import { ListInsertImageStrategy } from '../action-handle-strategies/modify-content-strategies/list-insert-image-strategy';
+import { ListNestItemsStrategy } from '../action-handle-strategies/modify-content-strategies/list-nest-items-strategy';
+import { ListUnnestItemsStrategy } from '../action-handle-strategies/modify-content-strategies/list-unnest-items-strategy';
 import { BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { ListAnnotation } from '../annotations/list-annotation';
 import { isNonNullable } from '../../../../types/type-guard';
@@ -12,7 +14,12 @@ import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annot
 import { CustomClassAnnotation } from '../annotations/custom-class-annotation';
 import { CustomStyleAnnotation } from '../annotations/custom-style-annotation';
 /**
- * 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 class RTEListBlock extends RTEBlock {
   constructor(id, type, options) {
@@ -126,5 +133,7 @@ export class RTEListBlock extends RTEBlock {
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_LIST_BLOCK, RTEListBlock.name, new ListTransformToListStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.TRANSFORM_PARAGRAPH_BLOCK, RTEListBlock.name, new ListTransformToParagraphStrategy());
   ActionHandleStrategyRegistry.register(ModifyContentActionType.INSERT_IMAGE_TO_BLOCK, RTEListBlock.name, new ListInsertImageStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.NEST_LIST_ITEMS, RTEListBlock.name, new ListNestItemsStrategy());
+  ActionHandleStrategyRegistry.register(ModifyContentActionType.UNNEST_LIST_ITEMS, RTEListBlock.name, new ListUnnestItemsStrategy());
 })();
 RTEListBlock.dtoName = 'RTEListBlock';

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

@@ -19,7 +19,11 @@ import { BlockUpdateTextStyleStrategy } from '../action-handle-strategies/apply-
 import { HorizontalAlignmentAnnotationAction } from '../actions/horizontal-alignment-annotation-action';
 import { BlockUpdateHorizontalAlignmentStrategy } from '../action-handle-strategies/apply-annotation-strategies/block-update-horizontal-alignment-strategy';
 /**
- * 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 class RTEListItemBlock extends RTETextBlock {
   constructor(id, nestList, options) {
@@ -46,7 +50,7 @@ export class RTEListItemBlock extends RTETextBlock {
     listItemBlock.children = block.nodes.map((richText) => RTETextNode.from(richText, listItemBlock, options));
     if (block.children) {
       listItemBlock.nestList = block.children.map((child) => {
-        const listBlock = RTEListBlock.from(child);
+        const listBlock = RTEListBlock.from(child, options);
         listBlock.parent = listItemBlock;
         return listBlock;
       });
@@ -73,8 +77,12 @@ export class RTEListItemBlock extends RTETextBlock {
    * @inheritDoc
    */
   toHtml(options) {
+    var _a;
     const attrStr = super.generateAttributeString(options);
-    return [`<li${attrStr}>`, this.getChildrenHtml(options), `</li>`].join('');
+    const nestListHtml = ((_a = this.nestList) === null || _a === void 0 ? void 0 : _a.length)
+      ? this.nestList.map((list) => list.toHtml(options)).join('')
+      : '';
+    return [`<li${attrStr}>`, this.getChildrenHtml(options), nestListHtml, `</li>`].join('');
   }
   /**
    * @inheritDoc

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