@heartlandone/vega 2.89.0 → 2.90.0

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

@@ -9,6 +9,8 @@ import RTETextNodeRenderer from '../nodes/text-node-renderer';
 import { isNonNullable } from '../../../../../types/type-guard';
 import { UnlinkLinkGroupAction } from '../../actions/unlink-link-group-action';
 import RTEDTORendererManager from '../../../../../helpers/rte-manager/dto-renderer-manager';
+import { VegaRTELinkExtension } from '../../../extensions/link/link-extension';
+import { normalizeUrlByDefaultProtocol } from '../../../extensions/link/utils';
 /**
  * Renders link nodes and wraps them with link editor or anchor element based on edit mode.
  */
@@ -50,7 +52,7 @@ class RTELinkWrapperRenderer {
    * @param {RTERenderContext} context - Context containing render options.
    * @returns {VegaRTERenderResult[]} - Array of rendered HTML elements.
    */
-  render(nodes, linkGroupAnnotation, { editable }) {
+  render(nodes, linkGroupAnnotation, { editable, host }) {
     const blockNodes = this.groupNodesByLink(nodes);
     return blockNodes
       .flatMap((item) => {
@@ -67,6 +69,8 @@ class RTELinkWrapperRenderer {
             return true;
           }
         });
+        this.normalizeLinkNodesByDefaultProtocol(item, host);
+        linkAnnotation = item[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
         return editable
           ? this.renderLinkEditorWrapper(item, linkAnnotation, linkGroupAnnotation)
           : this.renderLink(item, linkAnnotation, linkGroupAnnotation);
@@ -127,5 +131,36 @@ class RTELinkWrapperRenderer {
   renderLink(linkNodes, linkAnnotation, linkGroupAnnotation) {
     return (h("a", Object.assign({}, linkGroupAnnotation.toJsx(linkAnnotation)), linkNodes.map((node) => RTETextNodeRenderer.render(node))));
   }
+  normalizeLinkNodesByDefaultProtocol(linkNodes, host) {
+    if (!host || linkNodes.length === 0) {
+      return;
+    }
+    const firstLinkAnnotation = linkNodes[0].getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+    if (!firstLinkAnnotation) {
+      return;
+    }
+    const normalizedUrl = this.normalizeUrlByDefaultProtocol(firstLinkAnnotation.link.href, host);
+    if (!normalizedUrl || normalizedUrl === firstLinkAnnotation.link.href) {
+      return;
+    }
+    linkNodes.forEach((node) => {
+      const currentLinkAnnotation = node.getAnnotationByType(NodeAnnotationTypeEnum.LINK);
+      if (!currentLinkAnnotation || currentLinkAnnotation.link.href === normalizedUrl) {
+        return;
+      }
+      node.apply(new LinkAnnotationAction({
+        link: {
+          href: normalizedUrl,
+          groupKey: currentLinkAnnotation.link.groupKey,
+        },
+        type: 'update_link',
+        doSplit: false,
+      }));
+    });
+  }
+  normalizeUrlByDefaultProtocol(url, host) {
+    const linkConfig = VegaRTELinkExtension.configStore.get(host) || {};
+    return normalizeUrlByDefaultProtocol(url, linkConfig.defaultProtocol);
+  }
 }
 export default new RTELinkWrapperRenderer();

package/dist/collection/components/vega-rich-text-editor/extensions/base-toolbar-button-renderer.js

@@ -65,9 +65,10 @@ export class VegaRTEToolbarButtonRenderer {
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {(RTEDropdownListItem | RTEDropdownListGroup)[]} itemList - The list of dropdown items.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
    * @returns {VegaRTERenderResult} - The render result for the dropdown list.
    */
-  renderDropdownListTemplate(h, itemList) {
+  renderDropdownListTemplate(h, itemList, editorContext) {
     return h('div', {
       slot: 'items',
       onMouseDown: this.preventDefault,
@@ -82,8 +83,8 @@ export class VegaRTEToolbarButtonRenderer {
       h('style', { nonce: vegaNonceManager.nonce }, '.rte-dropdown-list vega-dropdown-group vega-dropdown-group { padding-left: 4px }'),
       ...itemList.map((item) => {
         return 'children' in item
-          ? this.renderDropdownGroup(h, item)
-          : this.renderDropdownItem(h, item);
+          ? this.renderDropdownGroup(h, item, editorContext)
+          : this.renderDropdownItem(h, item, editorContext);
       }),
     ]);
   }
@@ -92,32 +93,34 @@ export class VegaRTEToolbarButtonRenderer {
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {RTEDropdownListItem} item - The dropdown item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
    * @returns {VegaRTERenderResult} - The render result for the dropdown item.
    */
-  renderDropdownItem(h, item) {
+  renderDropdownItem(h, item, editorContext) {
     return h('vega-dropdown-item', {
       key: item.key,
       itemKey: item.key,
-      label: item.label,
+      label: editorContext.translation.t(item.label),
       prefixIcon: item.icon,
     });
   }
   /**
-   * Renders a dropdown item for the toolbar button.
+   * Renders a dropdown group for the toolbar button.
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {RTEDropdownListGroup} item - The dropdown group.
-   * @returns {VegaRTERenderResult} - The render result for the dropdown item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The render result for the dropdown group.
    */
-  renderDropdownGroup(h, item) {
+  renderDropdownGroup(h, item, editorContext) {
     return h('vega-dropdown-group', {
       key: item.key,
-      label: item.label,
+      label: editorContext.translation.t(item.label),
       divide: false,
     }, item.children.map((child) => {
       return 'children' in child
-        ? this.renderDropdownGroup(h, child)
-        : this.renderDropdownItem(h, child);
+        ? this.renderDropdownGroup(h, child, editorContext)
+        : this.renderDropdownItem(h, child, editorContext);
     }));
   }
   /**
@@ -176,7 +179,7 @@ export class VegaRTEToolbarButtonRenderer {
       return h('vega-font', {
         variant: 'font-field-label-sm',
         color: isDisabled ? 'text-disabled' : 'text-primary',
-      }, label);
+      }, editorContext.translation.t(label));
     }
     return null;
   }

package/dist/collection/components/vega-rich-text-editor/extensions/extension.abstract.js

@@ -9,6 +9,7 @@ import { ActionHandlerInterceptorRegistry } from '../dto/action-handle-strategie
 import { methodPlaceholder } from 'vega-slimmer/core';
 import htmlElementToAnnotationGenerator from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
 import { RTEFilterStylesStrategyRegistry } from '../dto/filter-styles-strategies/filter-styles-strategy-registry';
+import { RTEExtensionStateStore } from './rte-extension-state-store';
 const patchedBlockClasses = new WeakSet();
 const annotationHandlersByClass = new WeakMap();
 /**
@@ -98,6 +99,16 @@ export class VegaRTEExtension {
       return instance;
     };
   }
+  /**
+   * Create a per-host state store for this extension.
+   * Declare as `static readonly` to share store across extension instances while isolating state per RTE host.
+   *
+   * @template T - The type of the state value to store per host.
+   * @returns {RTEExtensionStateStore<T>} A new state store instance.
+   */
+  static createStateStore() {
+    return new RTEExtensionStateStore();
+  }
   /**
    * Lifecycle hook called by the rich text editor before the first render
    * (during `componentWillLoad`).  Override this method to perform per-host

package/dist/collection/components/vega-rich-text-editor/extensions/functions/renderers/function-toolbar-button-renderer.js

@@ -16,7 +16,7 @@ export class FunctionToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer
         showArrowIcon: true,
         tooltip: { text: 'Insert function' },
       }),
-      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST),
+      this.renderDropdownListTemplate(h, FunctionToolbarButtonRenderer.FUNCTION_LIST, editorContext),
     ]);
   }
   /**

package/dist/collection/components/vega-rich-text-editor/extensions/languages/language-toolbar-button-renderer.js

@@ -2,13 +2,8 @@ import { methodPlaceholder } from 'vega-slimmer/core';
 import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
 /**
  * Toolbar button renderer for language selection in Vega Rich Text Editor.
- *
- * Each {@link HTMLVegaRichTextEditorElement} that uses a language extension receives its
- * **own** instance of this renderer, registered in the per-host map inside
- * {@link RTEDTORendererManager} via {@link VegaRTEExtension#prepareBeforeLoad}.  Because
- * every editor has a dedicated renderer, all state (label DOM ref, selected language, and
- * the language-change callback) is held in plain instance fields — no WeakMaps or shared
- * singletons are required.
+ * Each editor host gets its own instance, registered via
+ * {@link VegaRTEExtension#prepareBeforeLoad}, so renderer state is held in plain fields.
  */
 export class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   constructor(languageList, languageChangeCallback, selectedLanguage = '') {
@@ -17,10 +12,9 @@ export class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRender
     this.languageChangeCallback = null;
     this.selectedLanguage = '';
     this.labelRef = null;
+    this.translation = null;
     /**
-     * Handles the language selection event.
-     * Because each editor has its own renderer instance, the language-change callback
-     * is stored directly on this instance — no indirect context lookup is needed.
+     * Handles the language selection event from the dropdown.
      *
      * @param {string} itemKey - The key of the selected language item.
      */
@@ -35,15 +29,18 @@ export class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRender
     this.selectedLanguage = selectedLanguage;
   }
   /**
-   * Updates the selected language and refreshes the button label text in-place,
-   * without requiring a full re-render of the toolbar.
+   * Updates the selected language and refreshes the button label text in-place
+   * without a full toolbar re-render. The label is routed through the translation
+   * helper so localization is preserved on imperative updates.
    *
    * @param {string} language The language key to set as selected.
    */
   setSelectedLanguage(language) {
+    var _a;
     this.selectedLanguage = language;
-    if (this.labelRef) {
-      this.labelRef.textContent = this.getLanguageLabelByKey(language);
+    if (((_a = this.labelRef) === null || _a === void 0 ? void 0 : _a.firstChild) && this.translation) {
+      const label = this.getLanguageLabelByKey(language);
+      this.labelRef.firstChild.nodeValue = this.translation.t(label);
     }
   }
   /**
@@ -58,7 +55,8 @@ export class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRender
    * @inheritDoc
    */
   render(createElement, editorContext) {
-    return this.renderDropdown(createElement, editorContext, { source: this.languageList }, [
+    const translatedSource = this.languageList.map((item) => this.translateDropdownEntry(item, editorContext));
+    return this.renderDropdown(createElement, editorContext, { source: translatedSource }, [
       this.renderButton(createElement, editorContext, {
         label: this.getLanguageLabelByKey(this.selectedLanguage),
         showArrowIcon: true,
@@ -73,6 +71,7 @@ export class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRender
    * @inheritDoc
    */
   renderButtonLabel(h, editorContext, label) {
+    this.translation = editorContext.translation;
     const isDisabled = this.isDisabled(editorContext);
     return h('vega-font', {
       variant: 'font-field-label-sm',
@@ -81,7 +80,7 @@ export class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRender
       ref: (el) => {
         this.labelRef = el;
       },
-    }, label);
+    }, editorContext.translation.t(label));
   }
   /* istanbul ignore next */
   /**
@@ -103,4 +102,19 @@ export class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRender
     const language = this.getListItemByKey(this.languageList, key);
     return (_a = language === null || language === void 0 ? void 0 : language.label) !== null && _a !== void 0 ? _a : 'Select Language';
   }
+  /**
+   * Recursively translates labels in a dropdown entry so that nested
+   * {@link RTEDropdownListGroup} children are also localized.
+   *
+   * @param {RTEDropdownListItem | RTEDropdownListGroup} entry The entry to translate.
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context.
+   * @returns {RTEDropdownListItem | RTEDropdownListGroup} The translated entry.
+   */
+  translateDropdownEntry(entry, editorContext) {
+    const translatedLabel = editorContext.translation.t(entry.label);
+    if ('children' in entry) {
+      return Object.assign(Object.assign({}, entry), { label: translatedLabel, children: entry.children.map((child) => this.translateDropdownEntry(child, editorContext)) });
+    }
+    return Object.assign(Object.assign({}, entry), { label: translatedLabel });
+  }
 }

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/line-height-toolbar-button-renderer.js

@@ -37,7 +37,7 @@ export class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRend
         showArrowIcon: true,
         tooltip: { text: VegaInternalTranslation.t('Line Height') },
       }),
-      this.renderDropdownListTemplate(createElement, dropdownItems),
+      this.renderDropdownListTemplate(createElement, dropdownItems, editorContext),
     ]);
   }
   /**

package/dist/collection/components/vega-rich-text-editor/extensions/link/link-extension.js

@@ -0,0 +1,34 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Rich Text Editor extension that configures built-in link behavior.
+ */
+export class VegaRTELinkExtension extends VegaRTEExtension {
+  constructor(config = {}) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Store config per host so both toolbar-link and inline-link editors
+   * can consistently read the extension settings.
+   *
+   * @param {HTMLElement} host - The host rich text editor element.
+   */
+  prepareBeforeLoad(host) {
+    VegaRTELinkExtension.configStore.set(host, this.config);
+  }
+  /**
+   * Remove config for the current host when the extension is destroyed.
+   */
+  destroyExtension() {
+    var _a;
+    if ((_a = this.extensionContext) === null || _a === void 0 ? void 0 : _a.host) {
+      VegaRTELinkExtension.configStore.delete(this.extensionContext.host);
+    }
+  }
+}
+/**
+ * Per-host config store. Declare as static readonly to isolate config per editor host.
+ *
+ * @type {RTEExtensionStateStore<VegaRTELinkExtensionConfig>}
+ */
+VegaRTELinkExtension.configStore = VegaRTELinkExtension.createStateStore();

package/dist/collection/components/vega-rich-text-editor/extensions/link/type.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/components/vega-rich-text-editor/extensions/link/utils.js

@@ -0,0 +1,22 @@
+// eslint-disable-next-line spellcheck/spell-checker
+// The regex checks for a protocol prefix (xxxx:// or xxxx:)
+// or a leading special character (such as /, #, +, etc., but not letters/digits/underscore).
+const PROTOCOL_REG_EXP = /^((\w+:(\/{2,})?)|(\W))/i;
+/**
+ * Normalizes URL by prepending default protocol when URL does not already include one.
+ *
+ * @param {string} url URL value to normalize.
+ * @param {string} defaultProtocol Configured default protocol, for example: https:// or mailto:.
+ * @returns {string} Normalized URL.
+ */
+export function normalizeUrlByDefaultProtocol(url, defaultProtocol) {
+  const input = (url || '').trim();
+  if (!input) {
+    return input;
+  }
+  const normalizedDefaultProtocol = (defaultProtocol || '').trim();
+  if (!normalizedDefaultProtocol || PROTOCOL_REG_EXP.test(input)) {
+    return input;
+  }
+  return `${normalizedDefaultProtocol}${input}`;
+}

package/dist/collection/components/vega-rich-text-editor/extensions/rte-extension-state-store.js

@@ -0,0 +1,37 @@
+/**
+ * Generic per-host state store using WeakMap keyed by HTMLVegaRichTextEditorElement.
+ * Create via {@link VegaRTEExtension.createStateStore} and declare as `static readonly` on your extension class.
+ *
+ * @template T - The type of the state value to store per host.
+ */
+export class RTEExtensionStateStore {
+  constructor() {
+    this.stateMap = new WeakMap();
+  }
+  /**
+   * Store a value for the given host.
+   *
+   * @param {HTMLElement} host - The editor host.
+   * @param {T} value - The value to store.
+   */
+  set(host, value) {
+    this.stateMap.set(host, value);
+  }
+  /**
+   * Retrieve the stored value for the given host.
+   *
+   * @param {Nullable<HTMLElement>} host - The editor host.
+   * @returns {Nullable<T>} The stored value, or null if not found.
+   */
+  get(host) {
+    return host ? this.stateMap.get(host) : null;
+  }
+  /**
+   * Remove the stored value for the given host.
+   *
+   * @param {HTMLElement} host - The editor host.
+   */
+  delete(host) {
+    this.stateMap.delete(host);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/tokens/token-toolbar-button-renderer.js

@@ -25,7 +25,7 @@ export class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer
         showArrowIcon: true,
         tooltip: { text: 'Insert token' },
       }),
-      this.renderDropdownListTemplate(createElement, this.tokenList),
+      this.renderDropdownListTemplate(createElement, this.tokenList, editorContext),
     ]);
   }
   /**

package/dist/collection/components/vega-rich-text-editor/public-api.js

@@ -23,6 +23,7 @@ export { VegaRTEHorizontalLineExtension } from './extensions/horizontal-line/hor
 export { VegaRTESpecialCharactersExtension } from './extensions/special-characters/special-characters-extension';
 export { VegaRTESpecialCharactersEssentials, VegaRTESpecialCharactersLatin, VegaRTESpecialCharactersMathematical, VegaRTESpecialCharactersArrows, VegaRTESpecialCharactersCurrency, VegaRTESpecialCharactersText, } from './extensions/special-characters/constants/default-categories';
 export { VegaRTELineHeightExtension } from './extensions/line-height/line-height-extension';
+export { VegaRTELinkExtension } from './extensions/link/link-extension';
 // actions
 export { ModifyContentAction, ModifyContentActionType } from './dto/actions/modify-content-action.abstract';
 export { AppendChildrenAction } from './dto/actions/append-child-nodes-action';

package/dist/collection/components/vega-rich-text-editor/slimmers/renderers/toolbar-renderer.js

@@ -55,7 +55,9 @@ export class ToolbarRenderer extends VegaSlimmer {
     return (h("vega-flex", { gap: "size-8", alignItems: "center", flexWrap: "wrap" },
       this.allowSourceEdit && (h(Fragment, null,
         h("div", { class: "toolbar-btn-group" }, this.sourceEditToolbarButtonSlimmer.render()),
-        this.toolbarItems.length > 0 && totalVisibleCount > 0 && this.renderVegaDivider())),
+        this.uniqueToolbarItems.length > 0 &&
+          totalVisibleCount > 0 &&
+          this.renderVegaDivider())),
       renderedItems));
   }
   renderVegaDivider() {
@@ -69,7 +71,7 @@ export class ToolbarRenderer extends VegaSlimmer {
    */
   renderToolbarItems() {
     let totalVisibleCount = 0;
-    const renderedItems = this.toolbarItems.map((group) => {
+    const renderedItems = this.uniqueToolbarItems.map((group) => {
       let visibleCountPerGroup = 0;
       const groupElement = group
         .map((item) => {
@@ -105,7 +107,7 @@ export class ToolbarRenderer extends VegaSlimmer {
 }
 __decorate([
   MapToComponentField()
-], ToolbarRenderer.prototype, "toolbarItems", void 0);
+], ToolbarRenderer.prototype, "uniqueToolbarItems", void 0);
 __decorate([
   MapToComponentField()
 ], ToolbarRenderer.prototype, "allowSourceEdit", void 0);

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

@@ -115,6 +115,19 @@ export class VegaRichTextEditor {
     this.selectionMap = new Map();
     this.isInDarkMode = VegaInternalThemeManager.isDarkMode();
     this.sourceView = false;
+    /**
+     * Internal state that holds unique toolbar items.
+     * Computed from `toolbarItems` to ensure each button renders only once.
+     *
+     *
+     * When `toolbarItems` contains duplicates across groups (e.g.,
+     * `[['bold'], ['italic'], ['bold']]`), only the first occurrence of each
+     * button is preserved. The group structure is maintained, but duplicate
+     * buttons are filtered out.
+     *
+     * @internal
+     */
+    this.uniqueToolbarItems = VegaRTEPresetToolbarItems;
     /**
      * Specifies the label for the rich text editor.
      *
@@ -250,6 +263,9 @@ export class VegaRichTextEditor {
   watchValueUpdate() {
     methodPlaceholder();
   }
+  watchToolbarItems() {
+    this.syncUniqueToolbarItems();
+  }
   watchValidationRules() {
     methodPlaceholder();
   }
@@ -258,10 +274,28 @@ export class VegaRichTextEditor {
   }
   componentWillLoad() {
     this.richTextContentController.syncRichTextContentEditable();
+    this.syncUniqueToolbarItems();
   }
   render() {
     return sanitizeVegaComponent(this.vegaRichTextEditorRenderer.render(), this.host);
   }
+  /**
+   * Synchronizes {@link uniqueToolbarItems} from {@link toolbarItems} using global uniqueness enforcement.
+   *
+   * Example:
+   * - input: [["bold", "italic"], ["bold", "link"], ["italic"]]
+   * - output: [["bold", "italic"], ["link"], []]
+   */
+  syncUniqueToolbarItems() {
+    const uniqueToolbarButtonSet = new Set();
+    this.uniqueToolbarItems = this.toolbarItems.map((toolbarItemGroup) => toolbarItemGroup.filter((toolbarItem) => {
+      if (uniqueToolbarButtonSet.has(toolbarItem)) {
+        return false;
+      }
+      uniqueToolbarButtonSet.add(toolbarItem);
+      return true;
+    }));
+  }
   static get is() { return "vega-rich-text-editor"; }
   static get encapsulation() { return "shadow"; }
   static get originalStyleUrls() { return {
@@ -639,7 +673,8 @@ export class VegaRichTextEditor {
     "richTextContentEditable": {},
     "selectionMap": {},
     "isInDarkMode": {},
-    "sourceView": {}
+    "sourceView": {},
+    "uniqueToolbarItems": {}
   }; }
   static get events() { return [{
       "method": "vegaChange",
@@ -792,6 +827,9 @@ export class VegaRichTextEditor {
     }, {
       "propName": "value",
       "methodName": "watchValueUpdate"
+    }, {
+      "propName": "toolbarItems",
+      "methodName": "watchToolbarItems"
     }, {
       "propName": "validationRules",
       "methodName": "watchValidationRules"

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/renderers/vega-rich-text-link-editor-renderer.js

@@ -12,16 +12,20 @@ import { VegaInternalComponentDidRender, VegaInternalPopoverUpdateTarget, } from
 import domNodeSubjectFactory from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
 import ChangeManager from '../../../../../helpers/change-manager/change-manager';
 import remoteInvocationRegistry from '../../../../../helpers/remote-invocation/remote-invocation-registry';
+import { findParent } from '../../../../../utils/ui';
+import { VegaRTELinkExtension } from '../../../extensions/link/link-extension';
+import { normalizeUrlByDefaultProtocol } from '../../../extensions/link/utils';
 export class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   constructor() {
     super(...arguments);
     this.handleKeyDown = (e) => {
       if (e.key === 'Enter') {
         void this.formRef.getValue().then(({ text, url }) => {
-          if (url.length > 0) {
+          const normalizedUrl = this.normalizeUrlByDefaultProtocol(url);
+          if (normalizedUrl.length > 0) {
             this.changeEventEmitter.emit({
               action: 'link',
-              payload: { text: text || url, url },
+              payload: { text: text || normalizedUrl, url: normalizedUrl },
             });
             void this.popoverRef.hide();
           }
@@ -58,13 +62,13 @@ export class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
     return (h("vega-popover", { trigger: "click", alignment: "start", placement: "bottom", showArrow: false, ref: (ref) => {
         this.popoverRef = ref;
         DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverShow, () => {
-          var _a, _b;
+          var _a, _b, _c;
           if (this.status === 'linkEdit') {
             void this.urlInputRef.doFocus();
           }
           void this.formRef.setValue({
             text: (_a = this.record) === null || _a === void 0 ? void 0 : _a.text,
-            url: (_b = this.record) === null || _b === void 0 ? void 0 : _b.url,
+            url: this.normalizeUrlByDefaultProtocol((_c = (_b = this.record) === null || _b === void 0 ? void 0 : _b.url) !== null && _c !== void 0 ? _c : ''),
           });
         });
         DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverHide, () => {
@@ -111,6 +115,11 @@ export class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   updatePopoverTarget() {
     remoteInvocationRegistry.call(domNodeSubjectFactory.getSubject(this.popoverRef, VegaInternalPopoverUpdateTarget), this.target);
   }
+  normalizeUrlByDefaultProtocol(url) {
+    const rteHost = findParent(this.host, 'vega-rich-text-editor');
+    const linkConfig = VegaRTELinkExtension.configStore.get(rteHost) || {};
+    return normalizeUrlByDefaultProtocol(url, linkConfig.defaultProtocol);
+  }
 }
 __decorate([
   MapToComponentField()

package/dist/collection/components/vega-selection-chip/vega-selection-chip-group/slimmers/renderers/vega-selection-chip-group-renderer.js

@@ -17,7 +17,7 @@ export class VegaSelectionChipGroupRenderer extends VegaSlimmer {
       this.renderHint()));
   }
   renderLabel() {
-    return (h("vega-field-label", { "is-field-required": this.required, disabled: this.disabled, label: this.label }));
+    return (h("vega-field-label", { "is-field-required": this.required, disabled: this.disabled, optional: this.optional, label: this.label }));
   }
   renderContainer() {
     return (h("div", { class: "container", ref: (ref) => (this.groupContainerRef = ref) },
@@ -37,6 +37,9 @@ __decorate([
 __decorate([
   MapToComponentField()
 ], VegaSelectionChipGroupRenderer.prototype, "required", void 0);
+__decorate([
+  MapToComponentField()
+], VegaSelectionChipGroupRenderer.prototype, "optional", void 0);
 __decorate([
   MapToComponentField()
 ], VegaSelectionChipGroupRenderer.prototype, "hint", void 0);

package/dist/collection/components/vega-selection-chip/vega-selection-chip-group/vega-selection-chip-group.js

@@ -67,6 +67,16 @@ export class VegaSelectionChipGroup {
      */
     /* eslint-disable-next-line @stencil/strict-mutable */
     this.value = this.selectType === 'checkbox' ? [] : '';
+    /**
+     * Indicates whether the field should be presented as optional.
+     *
+     * This property only takes effect when `required` is `false`.
+     * When `true`, an "optional" label is displayed next to the field label.
+     *
+     * @default false
+     * @vegaVersion 2.90.0
+     */
+    this.optional = false;
     /**
      * Defines custom validation rules for the selection chip group field.
      *
@@ -213,6 +223,30 @@ export class VegaSelectionChipGroup {
       "attribute": "required",
       "reflect": false
     },
+    "optional": {
+      "type": "boolean",
+      "mutable": false,
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [{
+            "name": "default",
+            "text": "false"
+          }, {
+            "name": "vegaVersion",
+            "text": "2.90.0"
+          }],
+        "text": "Indicates whether the field should be presented as optional.\n\nThis property only takes effect when `required` is `false`.\nWhen `true`, an \"optional\" label is displayed next to the field label."
+      },
+      "attribute": "optional",
+      "reflect": true,
+      "defaultValue": "false"
+    },
     "disabled": {
       "type": "boolean",
       "mutable": false,

package/dist/collection/components/vega-tab-group/slimmers/vega-tab-group/controllers/vega-tab-group-pages-controller.js

@@ -179,11 +179,13 @@ export class VegaTabGroupPagesController extends PageResizeObserverSlimmer {
    */
   /* istanbul ignore next */
   /**
-   * 1.record the width of tab.
-   * 2.the width of every tab is zero if the tab group component embedded in modal, so need recalculate the width of tab.
+   * 1. Record the width of each tab.
+   * 2. Recalculate when widths are zero, such as when the tab group is embedded in a modal before render.
+   * 3. Recalculate when tab count changes to ensure overflow navigation buttons stay in sync.
    */
   initTabsWidthArray() {
     if (this.tabWidthArray.length === 0 ||
+      this.tabWidthArray.length !== this.tabItems.length ||
       this.tabWidthArray.some((tabWidth) => tabWidth === 0)) {
       const newTabWidthArray = [];
       this.tabItems.forEach((item) => {