@heartlandone/vega 2.35.0-RTE-preview → 2.35.0

package/dist/esm/vega-rich-text-content.entry.js

@@ -4,7 +4,7 @@ import { V as VegaComponentUsageRuntimeMetricsSlimmer, I as InjectVegaGlobalSlim
 import { s as sanitizeVegaComponent } from './component-cae24190.js';
 import { s as stateEntityRenderingRegistry, B as BlockAnnotation, N as NodeAnnotation, c as NodeAnnotationTypeEnum, I as InternalAnnotationTypeEnum, e as VegaDarkModeStyleController } from './node-annotation.abstract-d7d52bce.js';
 import { T as TextNodeRenderingRegistry, I as ImageAnnotationAction, a as TextColorToolbarButtonSlimmer } from './image-annotation-action-a8e00f28.js';
-import { Z as ZERO_WIDTH_SPACE, L as LinkAnnotationAction, I as ImageAnnotation, b as RTETextBlock, c as RTEListItemBlock, R as RTEListBlock, a as RTEImageBlock, d as waitForComponentDidRender } from './list-block-ba82c846.js';
+import { Z as ZERO_WIDTH_SPACE, L as LinkAnnotationAction, b as RTETextBlock, I as ImageAnnotation, a as RTEImageBlock, R as RTEListBlock, d as waitForComponentDidRender } from './list-block-ba82c846.js';
 import { i as isNonNullable } from './type-guard-158f6d7a.js';
 import { g as generateUUID } from './create-public-api-runtime-metrics-slimmer-9ab05523.js';
 import { c as createEnterKeyHandlerToTriggerClick } from './accessibility-e5fd0fab.js';
@@ -25,22 +25,19 @@ import './typography-396de03f.js';
 import './dynamic-slimmer-90b8af32.js';
 
 class RTEBlockRenderer {
-  constructor(block, renderContext) {
-    this.block = block;
-    this.renderContext = renderContext;
-  }
-  registerRef(ref) {
+  registerRef(ref, block) {
     if (ref) {
-      stateEntityRenderingRegistry.register(ref, this.block);
+      stateEntityRenderingRegistry.register(ref, block);
     }
   }
   /**
    * Get styles from annotations
    *
+   * @param {RTEBlock} block - RTE block entity
    * @returns {AnnotationStyle} - Annotation style
    */
-  getStyles() {
-    return Array.from(this.block.annotationMap.values())
+  getStyles(block) {
+    return Array.from(block.annotationMap.values())
       .filter((annotation) => annotation instanceof BlockAnnotation)
       .map((annotation) => annotation.render())
       .filter(isNonNullable)
@@ -49,10 +46,11 @@ class RTEBlockRenderer {
   /**
    * Get classes from annotations
    *
+   * @param {RTEBlock} block - RTE block entity
    * @returns {AnnotationStyle} - Annotation style
    */
-  getClasses() {
-    return Array.from(this.block.annotationMap.values())
+  getClasses(block) {
+    return Array.from(block.annotationMap.values())
       .map((annotation) => { var _a; return (_a = annotation.renderClass) === null || _a === void 0 ? void 0 : _a.call(annotation); })
       .filter(isNonNullable)
       .reduce((pre, cur) => [pre, cur].join(' '), '');
@@ -60,22 +58,19 @@ class RTEBlockRenderer {
 }
 
 class RTENodeRenderer {
-  constructor(node, renderContext) {
-    this.node = node;
-    this.renderContext = renderContext;
-  }
-  registerRef(ref) {
+  registerRef(ref, node) {
     if (ref) {
-      stateEntityRenderingRegistry.register(ref, this.node);
+      stateEntityRenderingRegistry.register(ref, node);
     }
   }
   /**
    * Get styles from annotations
    *
+   * @param {RTENode} node - The DTO node
    * @returns {AnnotationStyle} - Annotation style
    */
-  getStyles() {
-    return Array.from(this.node.annotationMap.values())
+  getStyles(node) {
+    return Array.from(node.annotationMap.values())
       .filter((annotation) => annotation instanceof NodeAnnotation)
       .map((annotation) => annotation.render())
       .filter(Boolean)
@@ -84,10 +79,11 @@ class RTENodeRenderer {
   /**
    * Get classes from annotations
    *
+   * @param {RTENode} node - The DTO node
    * @returns {AnnotationStyle} - Annotation style
    */
-  getClasses() {
-    return Array.from(this.node.annotationMap.values())
+  getClasses(node) {
+    return Array.from(node.annotationMap.values())
       .filter((annotation) => annotation instanceof NodeAnnotation)
       .map((annotation) => { var _a; return (_a = annotation.renderClass) === null || _a === void 0 ? void 0 : _a.call(annotation); })
       .filter(Boolean)
@@ -96,55 +92,34 @@ class RTENodeRenderer {
 }
 
 class RTETextNodeRenderer extends RTENodeRenderer {
-  constructor(node, renderContext) {
-    super(node, renderContext);
-  }
-  render() {
-    const codeAnnotation = this.node.annotationMap.get(NodeAnnotationTypeEnum.CODE);
+  render(node) {
+    const codeAnnotation = node.annotationMap.get(NodeAnnotationTypeEnum.CODE);
     if (codeAnnotation === null || codeAnnotation === void 0 ? void 0 : codeAnnotation.code) {
-      return (h("code", { style: super.getStyles(), class: super.getClasses(), ref: (ref) => this.registerRef(ref) }, this.node.text || ZERO_WIDTH_SPACE));
+      return (h("code", { style: super.getStyles(node), class: super.getClasses(node), ref: (ref) => this.registerRef(ref, node) }, node.text || ZERO_WIDTH_SPACE));
     }
-    return (h("span", { style: super.getStyles(), class: super.getClasses(), ref: (ref) => this.registerRef(ref) }, this.node.text || ZERO_WIDTH_SPACE));
+    return (h("span", { style: super.getStyles(node), class: super.getClasses(node), ref: (ref) => this.registerRef(ref, node) }, node.text || ZERO_WIDTH_SPACE));
   }
-  registerRef(ref) {
-    super.registerRef(ref);
+  registerRef(ref, node) {
+    super.registerRef(ref, node);
     if (ref) {
-      const textColorAnnotation = this.node.getAnnotationByType('TEXT_COLOR');
+      const textColorAnnotation = node.getAnnotationByType('TEXT_COLOR');
       if (textColorAnnotation) {
         TextNodeRenderingRegistry.register(ref, textColorAnnotation);
       }
     }
   }
 }
+const RTETextNodeRenderer$1 = new RTETextNodeRenderer();
 
-class RTETextBlockRenderer extends RTEBlockRenderer {
-  constructor(block, renderContext) {
-    super(block, renderContext);
-  }
-  render() {
-    const BlockTag = this.getBlockTagByType(this.block.type);
-    return (h(BlockTag, { ref: (ref) => super.registerRef(ref), style: super.getStyles(), class: super.getClasses() }, this.renderNodes()));
-  }
-  renderNodes() {
-    const linkGroupAnnotation = this.block.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
+/**
+ * Abstract class for rendering blocks that contain text nodes with support for rendering text with link styles.
+ */
+class RTEBlockTextNodesRenderer extends RTEBlockRenderer {
+  renderNodes(block, renderContext) {
+    const linkGroupAnnotation = block.getAnnotationByType(InternalAnnotationTypeEnum.LINK_GROUP);
     return linkGroupAnnotation
-      ? this.renderLinkNodes(this.block.nodes, this.renderContext)
-      : this.block.nodes.map((node) => new RTETextNodeRenderer(node, this.renderContext).render());
-  }
-  getBlockTagByType(type) {
-    switch (type) {
-      case 'title':
-      case 'subtitle':
-        return `div`;
-      case 'heading-1':
-        return `h1`;
-      case 'heading-2':
-        return `h2`;
-      case 'heading-3':
-        return `h3`;
-      case 'paragraph':
-        return 'p';
-    }
+      ? this.renderLinkNodes(block.nodes, renderContext)
+      : block.nodes.map((node) => RTETextNodeRenderer$1.render(node));
   }
   renderLinkNodes(nodes, { editable }) {
     const blockNodes = this.groupNodesByLink(nodes);
@@ -155,7 +130,7 @@ class RTETextBlockRenderer extends RTEBlockRenderer {
           ? this.renderLinkEditorWrapper(item, linkAnnotation)
           : this.renderLink(item, linkAnnotation);
       }
-      return new RTETextNodeRenderer(item).render();
+      return RTETextNodeRenderer$1.render(item);
     });
   }
   groupNodesByLink(nodes) {
@@ -226,19 +201,45 @@ class RTETextBlockRenderer extends RTEBlockRenderer {
   }
   renderLink(linkNodes, linkAnnotation) {
     const { href } = linkAnnotation.link;
-    return (h("a", { class: "v-rte--link", href: href, target: "_blank" }, linkNodes.map((node) => new RTETextNodeRenderer(node).render())));
+    return (h("a", { class: "v-rte--link", href: href, target: "_blank" }, linkNodes.map((node) => RTETextNodeRenderer$1.render(node))));
   }
 }
 
+class RTETextBlockRenderer extends RTEBlockTextNodesRenderer {
+  canHandle(block) {
+    return block instanceof RTETextBlock;
+  }
+  render(block, renderContext) {
+    const BlockTag = this.getBlockTagByType(block.type);
+    return (h(BlockTag, { ref: (ref) => super.registerRef(ref, block), style: super.getStyles(block), class: super.getClasses(block) }, super.renderNodes(block, renderContext)));
+  }
+  getBlockTagByType(type) {
+    switch (type) {
+      case 'title':
+      case 'subtitle':
+        return `div`;
+      case 'heading-1':
+        return `h1`;
+      case 'heading-2':
+        return `h2`;
+      case 'heading-3':
+        return `h3`;
+      case 'paragraph':
+        return 'p';
+    }
+  }
+}
+const RTETextBlockRenderer$1 = new RTETextBlockRenderer();
+
 class RTEImageNodeRenderer extends RTENodeRenderer {
-  constructor(node, renderContext) {
-    super(node, renderContext);
-    this.handleChange = ({ detail, }) => {
+  constructor() {
+    super(...arguments);
+    this.handleChange = ({ detail }, node) => {
       switch (detail.action) {
         case 'edit': {
           const size = detail.payload.size;
           const alt = detail.payload.alt;
-          this.node.apply(new ImageAnnotationAction(size, alt));
+          node.apply(new ImageAnnotationAction(size, alt));
           break;
         }
         /*
@@ -252,59 +253,60 @@ class RTEImageNodeRenderer extends RTENodeRenderer {
             bubbles: true,
           });
           setTimeout(() => {
-            stateEntityRenderingRegistry.getDOMByEntity(this.node).dispatchEvent(event);
+            stateEntityRenderingRegistry.getDOMByEntity(node).dispatchEvent(event);
           }, 50);
           break;
         }
       }
     };
   }
-  render() {
-    const imageAnnotation = this.node.getAnnotationByType(NodeAnnotationTypeEnum.IMAGE);
+  render(node, renderContext) {
+    const imageAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.IMAGE);
     const { size, alt } = imageAnnotation || new ImageAnnotation('md', '');
-    return this.renderContext.editable ? (h("vega-rich-text-image-editor", { style: super.getStyles(), size: size, alt: alt, ref: (ref) => {
-        DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, this.handleChange);
-      } }, this.renderImage(alt))) : (this.renderImage(alt));
+    return renderContext.editable ? (h("vega-rich-text-image-editor", { style: super.getStyles(node), size: size, alt: alt, ref: (ref) => {
+        DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, (e) => this.handleChange(e, node));
+      } }, this.renderImage(alt, node, renderContext))) : (this.renderImage(alt, node, renderContext));
   }
-  renderImage(alt) {
-    return (h("img", { style: this.renderContext.editable ? { width: '100%' } : super.getStyles(), alt: alt, src: this.node.url, ref: (ref) => super.registerRef(ref) }));
+  renderImage(alt, node, renderContext) {
+    return (h("img", { style: renderContext.editable ? { width: '100%' } : super.getStyles(node), alt: alt, src: node.url, ref: (ref) => super.registerRef(ref, node) }));
   }
 }
+const RTEImageNodeRenderer$1 = new RTEImageNodeRenderer();
 
 class RTEImageBlockRenderer extends RTEBlockRenderer {
-  constructor(block, renderContext) {
-    super(block, renderContext);
+  canHandle(block) {
+    return block instanceof RTEImageBlock;
   }
-  render() {
-    return (h("div", { style: Object.assign({}, super.getStyles()), ref: (ref) => super.registerRef(ref), class: super.getClasses() }, this.block.nodes.map((node) => {
-      return new RTEImageNodeRenderer(node, this.renderContext).render();
+  render(block, renderContext) {
+    return (h("div", { style: Object.assign({}, super.getStyles(block)), ref: (ref) => super.registerRef(ref, block), class: super.getClasses(block) }, block.nodes.map((node) => {
+      return RTEImageNodeRenderer$1.render(node, renderContext);
     })));
   }
 }
+const RTEImageBlockRenderer$1 = new RTEImageBlockRenderer();
 
-class RTEListItemBlockRenderer extends RTETextBlockRenderer {
-  constructor(block, renderContext) {
-    super(block, renderContext);
+class RTEListItemBlockRenderer extends RTEBlockTextNodesRenderer {
+  render(block, renderContext) {
+    return (h("li", { ref: (ref) => super.registerRef(ref, block), style: super.getStyles(block), class: super.getClasses(block) },
+      super.renderNodes(block, renderContext),
+      this.renderChildren(block.children, renderContext)));
   }
-  render() {
-    return (h("li", { ref: (ref) => super.registerRef(ref), style: super.getStyles(), class: super.getClasses() },
-      super.renderNodes(),
-      this.renderChildren(this.block.children)));
-  }
-  renderChildren(children) {
-    return children === null || children === void 0 ? void 0 : children.map((block) => new RTEListBlockRenderer(block, this.renderContext).render());
+  renderChildren(children, renderContext) {
+    return children === null || children === void 0 ? void 0 : children.map((block) => RTEListBlockRenderer$1.render(block, renderContext));
   }
 }
+const RTEListItemBlockRenderer$1 = new RTEListItemBlockRenderer();
 
 class RTEListBlockRenderer extends RTEBlockRenderer {
-  constructor(block, renderContext) {
-    super(block, renderContext);
+  canHandle(block) {
+    return block instanceof RTEListBlock;
   }
-  render() {
-    const BlockTag = this.block.type === 'number-list' ? 'ol' : 'ul';
-    return (h(BlockTag, { ref: (ref) => super.registerRef(ref) }, this.block.blocks.map((listItemBlock) => new RTEListItemBlockRenderer(listItemBlock, this.renderContext).render())));
+  render(block, renderContext) {
+    const BlockTag = block.type === 'number-list' ? 'ol' : 'ul';
+    return (h(BlockTag, { ref: (ref) => super.registerRef(ref, block) }, block.blocks.map((listItemBlock) => RTEListItemBlockRenderer$1.render(listItemBlock, renderContext))));
   }
 }
+const RTEListBlockRenderer$1 = new RTEListBlockRenderer();
 
 var __decorate$2 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -315,6 +317,11 @@ var __decorate$2 = (undefined && undefined.__decorate) || function (decorators,
 class VegaRichTextContentRenderer extends VegaSlimmer {
   constructor() {
     super();
+    this.blockRenderers = [
+      RTETextBlockRenderer$1,
+      RTEImageBlockRenderer$1,
+      RTEListBlockRenderer$1,
+    ];
     VegaDarkModeStyleController.registerCustomDarkModeColor(TextColorToolbarButtonSlimmer.formatDarkModeColor());
   }
   /**
@@ -336,19 +343,14 @@ class VegaRichTextContentRenderer extends VegaSlimmer {
     var _a;
     const renderContext = { editable: this.contentEditable };
     return (_a = this.content) === null || _a === void 0 ? void 0 : _a.blocks.map((block) => {
-      return this.getBlockRenderer(block, renderContext).render();
+      const blockRenderer = this.getBlockRenderer(block);
+      if (blockRenderer) {
+        return blockRenderer.render(block, renderContext);
+      }
     });
   }
-  getBlockRenderer(block, renderContext) {
-    if (block instanceof RTETextBlock && !(block instanceof RTEListItemBlock)) {
-      return new RTETextBlockRenderer(block, renderContext);
-    }
-    else if (block instanceof RTEListBlock) {
-      return new RTEListBlockRenderer(block, renderContext);
-    }
-    else if (block instanceof RTEImageBlock) {
-      return new RTEImageBlockRenderer(block, renderContext);
-    }
+  getBlockRenderer(block) {
+    return this.blockRenderers.find((renderer) => renderer.canHandle(block));
   }
   shouldShowPlaceholder() {
     var _a;

package/dist/esm/vega-rich-text-editor_4.entry.js

@@ -12,7 +12,7 @@ import { g as RTETextNode, i as BoldAnnotationAction, T as TextSplittableAction,
 import { c as NodeAnnotationTypeEnum, a as BlockAnnotationTypeEnum, M as ModifyContentAction, b as ModifyContentActionType, R as RTENode, s as stateEntityRenderingRegistry, I as InternalAnnotationTypeEnum, V as VegaThemeManager } from './node-annotation.abstract-d7d52bce.js';
 import { D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-dc486a8b.js';
 import { g as generateUUID } from './create-public-api-runtime-metrics-slimmer-9ab05523.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { c as createEventEmitSlimmer } from './event-emit-slimmer-f285e3ac.js';
 import { c as createSubStateNotifySlimmer } from './sub-state-notify-slimmer-48bad548.js';
 import { d as debounce } from './timer-9321173b.js';
@@ -3658,12 +3658,60 @@ class SpanImageToRTEImageBlockStrategy extends BlockToRTEBlockStrategyAbstract {
   }
 }
 
+/** Transform child element of UL element which are not LI element to list item block DTO */
+class ULNotLiChildToRTEListItemBlockStrategy extends BlockToRTEBlockStrategyAbstract {
+  /**
+   * Can be handle.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @param {number} currentIndex - Current element index.
+   * @returns {number} - can be handled element count.
+   */
+  canHandle(elementsArray, currentIndex) {
+    const element = elementsArray[currentIndex];
+    const parent = element.parentElement;
+    return element.nodeName !== 'LI' && parent && ['UL', 'OL'].includes(parent.nodeName) ? 1 : 0;
+  }
+  /**
+   * Parse to a list item block.
+   *
+   * @param {HTMLElement[]} elementsArray - Current elements.
+   * @returns {Nullable<RTEContentBlock>} - List item block.
+   */
+  handle(elementsArray) {
+    const nodes = this.generateChildNodes(elementsArray);
+    if (nodes.length === 0)
+      return null;
+    return RTEListItemBlock.from({
+      id: generateUUID(),
+      type: 'list-item',
+      nodes: nodes,
+      annotations: {},
+    });
+  }
+  /* istanbul ignore next */
+  /**
+   * Append child blocks.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  appendChildBlocks() { }
+  /**
+   * Should continue process to child elements.
+   *
+   * @returns {boolean} - boolean.
+   */
+  shouldProceedToElementChildren() {
+    return false;
+  }
+}
+
 /** Element to DTO processor */
 class ElementToDtoStrategyProcessor {
   constructor() {
     this.elementStrategies = [
       new UlToRTEListBlockStrategy(),
       new OlToRTEListBlockStrategy(),
+      new ULNotLiChildToRTEListItemBlockStrategy(),
       new LiToRTEListItemBlockStrategy(),
       new InlineBlockToRTETextBlockStrategy(),
       new ImgToRTEImageBlockStrategy(),

package/dist/esm/vega-selection-chip_2.entry.js

@@ -18,7 +18,7 @@ import { a as TagNameAndAttributeMutationFilter } from './mutation-observer-filt
 import { i as isArrayEqual } from './array-b668466e.js';
 import { c as createSubStateNotifySlimmer } from './sub-state-notify-slimmer-48bad548.js';
 import { C as ChildNodesEventPreventSlimmer } from './child-nodes-event-prevent-slimmer-97aae8a8.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { R as RequiredFieldRule } from './required-field-rule-368b31fa.js';
 import './type-guard-158f6d7a.js';
 import './breakpoints-d9faf11c.js';

package/dist/esm/vega-selection-tile_2.entry.js

@@ -13,7 +13,7 @@ import { f as findParent } from './ui-62e4be97.js';
 import { C as ChildNodesEventPreventSlimmer } from './child-nodes-event-prevent-slimmer-97aae8a8.js';
 import { C as ChildNodesNotifyObserverSlimmer } from './child-nodes-notify-observer-slimmer-289caacc.js';
 import { c as createSubStateNotifySlimmer } from './sub-state-notify-slimmer-48bad548.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { R as RequiredFieldRule } from './required-field-rule-368b31fa.js';
 import './dynamic-slimmer-90b8af32.js';
 import './dom-node-subject-observer-factory-dc486a8b.js';

package/dist/esm/vega-signature-capture.entry.js

@@ -10,7 +10,7 @@ import { b as FORM_ELEMENT_VALUE_CHANGE } from './static-subject-title-e06a3840.
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { d as deepEqual } from './object-261e7344.js';
 import { c as createEventEmitSlimmer } from './event-emit-slimmer-f285e3ac.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { R as RequiredFieldRule } from './required-field-rule-368b31fa.js';
 import { P as PageResizeObserverSlimmer } from './page-resize-observer-slimmer-beb7b0bd.js';
 import { g as getCurrentBreakpoint } from './breakpoints-91116111.js';

package/dist/esm/vega-stepper.entry.js

@@ -4,7 +4,7 @@ import { s as sanitizeVegaComponent } from './component-cae24190.js';
 import { c as convertToNumber, n as normalizeNumberByRanger } from './number-4398f2e1.js';
 import { I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { V as VegaComponentUsageRuntimeMetricsSlimmer, I as InjectVegaGlobalSlimmer } from './component-usage-runtime-metrics-385c7124.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { C as ChildNodesEventPreventSlimmer } from './child-nodes-event-prevent-slimmer-97aae8a8.js';
 import { D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-dc486a8b.js';
 import { f as VegaChange, A as VegaBlur, a as VegaClick } from './dom-node-subject-factory-5831cdd4.js';

package/dist/esm/vega-tab-group_2.entry.js

@@ -94,7 +94,12 @@ class VegaTabGroupSelectedTargetController extends VegaSlimmer {
   handleTabItemClick(dataTarget) {
     const clickEvent = this.clickEventEmitter.emit(dataTarget);
     if (clickEvent && !clickEvent.defaultPrevented) {
-      this.setSelectedDataTarget(dataTarget);
+      if (dataTarget === this.selectedTabDataTarget) {
+        this.vegaTabGroupPageIndexController.setCurrentPageIndexBySelectedTab(dataTarget);
+      }
+      else {
+        this.setSelectedDataTarget(dataTarget);
+      }
     }
   }
 }
@@ -104,6 +109,9 @@ __decorate$a([
 __decorate$a([
   MapToComponentField({ writable: true })
 ], VegaTabGroupSelectedTargetController.prototype, "selectedTabDataTarget", void 0);
+__decorate$a([
+  MapToComponentField()
+], VegaTabGroupSelectedTargetController.prototype, "vegaTabGroupPageIndexController", void 0);
 
 /**
  * It takes an array of items, an array of values, and a capacity, and returns an array of arrays of
@@ -422,6 +430,28 @@ class VegaTabGroupPageIndexController extends VegaSlimmer {
   handleSelectedDataTargetChange() {
     this.setCurrentPageIndexBySelectedTab(this.selectedTabDataTarget);
   }
+  /*
+   * The below method is e2e-test covered in
+   * @see{module:vega-tab-group-with-click-tab-in-dropdown}
+   */
+  /* istanbul ignore next */
+  /**
+   * Update the page index after the tab click
+   *
+   * @param {string} selectedTabDataTarget the tab item property dataTarget
+   */
+  setCurrentPageIndexBySelectedTab(selectedTabDataTarget) {
+    let pageIndex = -1;
+    this.tabPages.forEach((tabPage, index) => {
+      const tabIndex = tabPage.findIndex((tab) => tab.dataTarget === selectedTabDataTarget);
+      if (tabIndex !== -1) {
+        pageIndex = index;
+      }
+    });
+    if (pageIndex >= 0) {
+      this.currentPageIndex = pageIndex;
+    }
+  }
   /* istanbul ignore next */
   /**
    * The `setPageIndex` function sets the current page index to the specified value.
@@ -445,28 +475,6 @@ class VegaTabGroupPageIndexController extends VegaSlimmer {
       this.currentPageIndex = this.tabPages.length - 1;
     }
   }
-  /*
-   * The below method is e2e-test covered in
-   * @see{module:vega-tab-group-with-click-tab-in-dropdown}
-   */
-  /* istanbul ignore next */
-  /**
-   * Update the page index after the tab click
-   *
-   * @param {string} selectedTabDataTarget the tab item property dataTarget
-   */
-  setCurrentPageIndexBySelectedTab(selectedTabDataTarget) {
-    let pageIndex = -1;
-    this.tabPages.forEach((tabPage, index) => {
-      const tabIndex = tabPage.findIndex((tab) => tab.dataTarget === selectedTabDataTarget);
-      if (tabIndex !== -1) {
-        pageIndex = index;
-      }
-    });
-    if (pageIndex >= 0) {
-      this.currentPageIndex = pageIndex;
-    }
-  }
 }
 __decorate$8([
   MapToComponentField()
@@ -594,6 +602,9 @@ class VegaTabGroupSwitchPageButtonRenderer extends VegaSlimmer {
       ? this.currentPageIndex === 0
       : this.currentPageIndex + 1 === this.tabPages.length || this.tabPages.length <= 1;
     const icon = direction === 'left' ? 'chevron-backward-rounded' : 'chevron-forward-rounded';
+    const selectedItemKey = source.find((item) => item.key === this.selectedTabDataTarget)
+      ? this.selectedTabDataTarget
+      : '';
     return (h("div", { class: {
         'tab-left-button': direction === 'left',
         'tab-right-button': direction === 'right',
@@ -601,7 +612,7 @@ class VegaTabGroupSwitchPageButtonRenderer extends VegaSlimmer {
       }, 
       /* eslint-disable-next-line react/jsx-no-bind */
       onClick: () => this.onDirectionButtonClick(direction), "aria-label": "No label defined", role: 'button', tabIndex: 0, onKeyDown: createEnterKeyHandlerToTriggerClick() },
-      h("vega-dropdown", { source: source, translocation: translocation, selectType: "single", selectedSourceKey: this.selectedTabDataTarget, "position-relative-to": this.positionRelativeTo, ref: (ref) => {
+      h("vega-dropdown", { source: source, translocation: translocation, selectType: "single", selectedSourceKey: selectedItemKey, "position-relative-to": this.positionRelativeTo, ref: (ref) => {
           this.dropdownRef = ref;
           DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaDropdownClick, (payload) => {
             this.vegaTabGroupSelectedTargetController.handleTabItemClick(payload.detail);

package/dist/esm/vega-textarea.entry.js

@@ -4,7 +4,7 @@ import { R as RequiredFieldRule } from './required-field-rule-368b31fa.js';
 import { s as sanitizeVegaComponent } from './component-cae24190.js';
 import { I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { V as VegaComponentUsageRuntimeMetricsSlimmer, I as InjectVegaGlobalSlimmer } from './component-usage-runtime-metrics-385c7124.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { b as FORM_ELEMENT_VALUE_CHANGE } from './static-subject-title-e06a3840.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import { c as createEventEmitSlimmer } from './event-emit-slimmer-f285e3ac.js';

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

@@ -4,7 +4,7 @@ import { d as isTimeStr, p as pad, e as convert12HourTo24HourFormat } from './da
 import { s as sanitizeVegaComponent } from './component-cae24190.js';
 import { c as MapToComponentField, V as VegaSlimmer, M as MapToComponentMethod, L as LogUtility, I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { V as VegaComponentUsageRuntimeMetricsSlimmer, I as InjectVegaGlobalSlimmer } from './component-usage-runtime-metrics-385c7124.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { D as DomNodeSubjectObserverFactory } from './dom-node-subject-observer-factory-dc486a8b.js';
 import { f as VegaChange, z as VegaFocus, A as VegaBlur, a as VegaClick } from './dom-node-subject-factory-5831cdd4.js';
 import { g as getDeviceType, D as DeviceType } from './ui-62e4be97.js';

package/dist/esm/vega-toggle-switch.entry.js

@@ -5,7 +5,7 @@ import { c as createEnterKeyHandlerToTriggerClick } from './accessibility-e5fd0f
 import { s as sanitizeVegaComponent } from './component-cae24190.js';
 import { I as InjectVegaSlimmer } from './global-slimmer-registry-17c4efd4.js';
 import { V as VegaComponentUsageRuntimeMetricsSlimmer, I as InjectVegaGlobalSlimmer } from './component-usage-runtime-metrics-385c7124.js';
-import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-af969d03.js';
+import { F as FormFieldControllerSlimmer } from './form-field-controller-slimmer-add614f1.js';
 import { b as FORM_ELEMENT_VALUE_CHANGE } from './static-subject-title-e06a3840.js';
 import { C as ChangeManager } from './change-manager-6a7eb88c.js';
 import './ui-62e4be97.js';