@heartlandone/vega 2.88.0 → 2.90.0

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/dto/horizontal-line-annotation.d.ts

@@ -0,0 +1,43 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+export declare enum RTEHorizontalLineExtensionAnnotationTypeEnum {
+  HORIZONTAL_LINE = "HORIZONTAL_LINE"
+}
+/**
+ * Horizontal line annotation.
+ * Mirrors {@link TextStyleAnnotation}: emits the HR default visual styles in
+ * standalone mode (source edit) and the corresponding class in normal mode.
+ * Only added to the block when `autoMatchFormat` is enabled.
+ */
+export declare class HorizontalLineAnnotation extends BlockAnnotation<RTEHorizontalLineExtensionAnnotationTypeEnum> {
+  readonly type: RTEHorizontalLineExtensionAnnotationTypeEnum;
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, HorizontalLineAnnotation]} Map item.
+   */
+  static from(): [RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, HorizontalLineAnnotation];
+  /**
+   * Get the default styles for the horizontal line element.
+   *
+   * @returns {AnnotationStyle} The default styles.
+   */
+  static getDefaultStyles(): AnnotationStyle;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+  /**
+   * @inheritDoc
+   */
+  clone(): HorizontalLineAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/dto/horizontal-line-block.d.ts

@@ -0,0 +1,53 @@
+import { VegaRTEBlockAnnotations, VegaRTECustomBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTEHtmlBlock } from '../../../dto/blocks/html-block';
+import { RTEHorizontalLineNode } from './horizontal-line-node';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+/**
+ * Horizontal line block — a block containing a single `<hr>` decorator node.
+ */
+export declare class RTEHorizontalLineBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEHorizontalLineNode> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
+  readonly type: string;
+  children: RTEHorizontalLineNode[];
+  parent: VegaRTEContent | RTEHtmlBlock;
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * Creates an RTEHorizontalLineBlock from a JSON representation.
+   *
+   * @param {VegaRTECustomBlock} block - The block JSON to convert.
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} The created block instance.
+   */
+  static from(block: VegaRTECustomBlock, options?: VegaRTETransformOptions): RTEHorizontalLineBlock;
+  /**
+   * Creates a new RTEHorizontalLineBlock with a child node.
+   *
+   * @param {VegaRTEBlockAnnotations} [annotations] - Optional annotations (e.g. customStyle overrides).
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} A new block instance.
+   */
+  static create(annotations?: VegaRTEBlockAnnotations, options?: VegaRTETransformOptions): RTEHorizontalLineBlock;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTECustomBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(options?: VegaRTETransformOptions): string;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: VegaRTEContent | RTEHtmlBlock): RTEHorizontalLineBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/dto/horizontal-line-node.d.ts

@@ -0,0 +1,26 @@
+import { RTEDecoratorNode } from '../../../dto/nodes/decorator-node';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue } from '../../../interface';
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+/**
+ * Horizontal line node — a decorator node representing `<hr>` in the editor.
+ */
+export declare class RTEHorizontalLineNode extends RTEDecoratorNode<RTEBlock> {
+  readonly type: string;
+  parent: RTEBlock;
+  constructor(id: string, parentBlock: RTEBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * @inheritDoc
+   */
+  toJSON(): {
+    id: string;
+    type: string;
+  };
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTEBlock): RTEHorizontalLineNode;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/filter-styles-strategies/horizontal-line-block/horizontal-line-filter-styles-strategy.d.ts

@@ -0,0 +1,31 @@
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+/**
+ * Default visual styles for the `<hr>` element in the RTE.
+ * These styles match the CSS applied in `horizontal-line-block-styles.css`.
+ *
+ * @see {@link file://extensions/horizontal-line/renderers/horizontal-line-block-styles.css} — must stay in sync.
+ */
+export declare const HR_DEFAULT_STYLES: RTEFilterStyles;
+/**
+ * Filter styles strategy for horizontal line blocks.
+ * Strips default HR visual styles during output and refills them during input,
+ * ensuring source edit round-trips do not lose information.
+ */
+export declare class HorizontalLineFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/filter-styles-strategies/horizontal-line-block/predicate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Predicate class provides static methods to check specific conditions on HTML elements or dto instances.
+ */
+export declare class Predicate {
+  /**
+   * Checks if the given class name corresponds to a horizontal line block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a horizontal line block, false otherwise.
+   */
+  static isHorizontalLineBlock(className: string): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/horizontal-line-extension.d.ts

@@ -0,0 +1,9 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Extension that adds horizontal line (`<hr>`) support to the Vega Rich Text Editor.
+ */
+export declare class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
+  private blockRenderer;
+  private toolbarButtonRenderer;
+  constructor();
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/renderers/horizontal-line-block-renderer.d.ts

@@ -0,0 +1,16 @@
+import { VegaRTEExtensionRenderer } from '../../base-extension-renderer';
+import { RTEHorizontalLineBlock } from '../dto/horizontal-line-block';
+import { RTERenderContext, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+/**
+ * Renderer for horizontal line blocks in the rich text editor.
+ */
+export declare class RTEHorizontalLineBlockRenderer extends VegaRTEExtensionRenderer {
+  /**
+   * @inheritDoc
+   */
+  doRender(createElement: VegaRTECreateElementFunction, block: RTEHorizontalLineBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  injectRTEScopeStyles(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/renderers/horizontal-line-toolbar-button-renderer.d.ts

@@ -0,0 +1,27 @@
+import { VegaRTEToolbarButtonRenderer } from '../../base-toolbar-button-renderer';
+import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../../interface';
+/**
+ * Toolbar button renderer for horizontal line insertion.
+ */
+export declare class RTEHorizontalLineToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * Renders the horizontal line toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} createElement - The function to create elements.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context.
+   * @returns {VegaRTERenderResult} The rendered toolbar button.
+   */
+  render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * @inheritDoc
+   */
+  protected isDisabled(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * @inheritDoc
+   */
+  protected handleDropdownClick(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/languages/language-toolbar-button-renderer.d.ts

@@ -3,23 +3,20 @@ import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
 export declare type LanguageSelectedCallback = (selectedLanguage: string) => void;
 /**
  * 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 declare class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   private languageList;
   private languageChangeCallback;
   private selectedLanguage;
   private labelRef;
+  private translation;
   constructor(languageList: (RTEDropdownListItem | RTEDropdownListGroup)[], languageChangeCallback: LanguageSelectedCallback, selectedLanguage?: string);
   /**
-   * 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.
    */
@@ -48,9 +45,7 @@ export declare class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButt
    */
   protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
   /**
-   * 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.
    */
@@ -62,4 +57,13 @@ export declare class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButt
    * @returns {string} The label of the language, or the key if not found.
    */
   private getLanguageLabelByKey;
+  /**
+   * 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.
+   */
+  private translateDropdownEntry;
 }

package/dist/types/components/vega-rich-text-editor/extensions/link/link-extension.d.ts

@@ -0,0 +1,27 @@
+import { VegaRTEExtension } from '../extension.abstract';
+import { VegaRTELinkExtensionConfig } from './type';
+import { RTEExtensionStateStore } from '../rte-extension-state-store';
+/**
+ * Rich Text Editor extension that configures built-in link behavior.
+ */
+export declare class VegaRTELinkExtension extends VegaRTEExtension {
+  private readonly config;
+  /**
+   * Per-host config store. Declare as static readonly to isolate config per editor host.
+   *
+   * @type {RTEExtensionStateStore<VegaRTELinkExtensionConfig>}
+   */
+  static readonly configStore: RTEExtensionStateStore<VegaRTELinkExtensionConfig>;
+  constructor(config?: VegaRTELinkExtensionConfig);
+  /**
+   * 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: HTMLVegaRichTextEditorElement): void;
+  /**
+   * Remove config for the current host when the extension is destroyed.
+   */
+  destroyExtension(): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/link/type.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Configurable options for the link extension.
+ */
+export declare type VegaRTELinkExtensionConfig = {
+  /**
+   * Optional protocol prefix used to normalize user-entered links.
+   *
+   * Examples:
+   * - `https://` + `abc.com` => `https://abc.com`
+   * - `mailto:` + `test@example.com` => `mailto:test@example.com`
+   * - `tel:` + `123456` => `tel:123456`
+   * - `/` + `about` => `/about`
+   */
+  defaultProtocol?: string;
+};

package/dist/types/components/vega-rich-text-editor/extensions/link/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 declare function normalizeUrlByDefaultProtocol(url: string, defaultProtocol: string): string;

package/dist/types/components/vega-rich-text-editor/extensions/rte-extension-state-store.d.ts

@@ -0,0 +1,30 @@
+import { Nullable } from '../../../types/general';
+/**
+ * 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 declare class RTEExtensionStateStore<T> {
+  private readonly stateMap;
+  /**
+   * Store a value for the given host.
+   *
+   * @param {HTMLElement} host - The editor host.
+   * @param {T} value - The value to store.
+   */
+  set(host: HTMLVegaRichTextEditorElement, value: T): void;
+  /**
+   * 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: Nullable<HTMLVegaRichTextEditorElement>): Nullable<T>;
+  /**
+   * Remove the stored value for the given host.
+   *
+   * @param {HTMLElement} host - The editor host.
+   */
+  delete(host: HTMLVegaRichTextEditorElement): void;
+}

package/dist/types/components/vega-rich-text-editor/public-api.d.ts

@@ -16,9 +16,11 @@ export { RTELanguageToolbarButtonRenderer } from './extensions/languages/languag
 export { VegaRTELanguageExtension } from './extensions/languages/language-extension';
 export { VegaRTEFunctionExtension } from './extensions/functions/function-extension';
 export { VegaRTETableExtension } from './extensions/table/table-extension';
+export { VegaRTEHorizontalLineExtension } from './extensions/horizontal-line/horizontal-line-extension';
 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';
 export { ModifyContentAction, ModifyContentActionType } from './dto/actions/modify-content-action.abstract';
 export { AppendChildrenAction } from './dto/actions/append-child-nodes-action';
 export { RemoveChildrenAction } from './dto/actions/remove-child-action';
@@ -40,4 +42,5 @@ export { htmlElementToAnnotationGenerator };
 export { VegaRTEDefaultTextStyleItems, VegaRTEPresetToolbarItems } from './constants/constant';
 export { VegaRTEDefaultLineHeightOptions } from './extensions/line-height/constants';
 export { VegaRTELineHeightOption } from './extensions/type';
+export { VegaRTELinkExtensionConfig } from './extensions/link/type';
 export { RTEFilterStylesStrategy } from './dto/filter-styles-strategies/filter-styles-strategy.abstract';

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/toolbar-renderer.d.ts

@@ -1,7 +1,7 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaRichTextEditor } from '../../vega-rich-text-editor';
 export declare class ToolbarRenderer extends VegaSlimmer {
-  toolbarItems: VegaRichTextEditor['toolbarItems'];
+  uniqueToolbarItems: VegaRichTextEditor['uniqueToolbarItems'];
   allowSourceEdit: VegaRichTextEditor['allowSourceEdit'];
   host: VegaRichTextEditor['host'];
   clearStyleToolbarButtonSlimmer: VegaRichTextEditor['clearStyleToolbarButtonSlimmer'];

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

@@ -99,6 +99,19 @@ export declare class VegaRichTextEditor {
   selectionMap: Map<RTEBlock, RTENode[]>;
   isInDarkMode: boolean;
   sourceView: boolean;
+  /**
+   * 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
+   */
+  uniqueToolbarItems: VegaRTEToolbarItem[][];
   /**
    * Specifies the label for the rich text editor.
    *
@@ -171,6 +184,7 @@ export declare class VegaRichTextEditor {
    * @vegaVersion 2.34.0
    */
   toolbarItems: VegaRTEToolbarItem[][];
+  watchToolbarItems(): void;
   /**
    * Determines whether to allow source edit mode in the rich text editor.
    *
@@ -265,4 +279,12 @@ export declare class VegaRichTextEditor {
   sourceCodeChange: EventEmitter<string>;
   componentWillLoad(): void;
   render(): VegaRichTextEditor;
+  /**
+   * Synchronizes {@link uniqueToolbarItems} from {@link toolbarItems} using global uniqueness enforcement.
+   *
+   * Example:
+   * - input: [["bold", "italic"], ["bold", "link"], ["italic"]]
+   * - output: [["bold", "italic"], ["link"], []]
+   */
+  private syncUniqueToolbarItems;
 }

package/dist/types/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/renderers/vega-rich-text-link-editor-renderer.d.ts

@@ -27,4 +27,5 @@ export declare class VegaRichTextLinkEditorRenderer extends VegaSlimmer {
   private renderLinkEditContent;
   private handleKeyDown;
   private updatePopoverTarget;
+  private normalizeUrlByDefaultProtocol;
 }

package/dist/types/components/vega-selection-chip/vega-selection-chip-group/slimmers/renderers/vega-selection-chip-group-renderer.d.ts

@@ -4,6 +4,7 @@ export declare class VegaSelectionChipGroupRenderer extends VegaSlimmer {
   host: VegaSelectionChipGroup['host'];
   label: VegaSelectionChipGroup['label'];
   required: VegaSelectionChipGroup['required'];
+  optional: VegaSelectionChipGroup['optional'];
   hint: VegaSelectionChipGroup['hint'];
   disabled: VegaSelectionChipGroup['disabled'];
   private groupContainerRef;

package/dist/types/components/vega-selection-chip/vega-selection-chip-group/vega-selection-chip-group.d.ts

@@ -65,6 +65,16 @@ export declare class VegaSelectionChipGroup {
    * @vegaVersion 2.22.0
    */
   required: boolean;
+  /**
+   * 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
+   */
+  optional: boolean;
   /**
    * Indicates if the selection chip group is disabled.
    *

package/dist/types/components/vega-selection-tile/vega-selection-tile-group/slimmers/renderers/vega-selection-tile-group-renderer.d.ts

@@ -4,14 +4,15 @@ export declare class VegaSelectionTileGroupRenderer extends VegaSlimmer {
   host: VegaSelectionTileGroup['host'];
   label: VegaSelectionTileGroup['label'];
   required: VegaSelectionTileGroup['required'];
+  optional: VegaSelectionTileGroup['optional'];
   hint: VegaSelectionTileGroup['hint'];
   layout: VegaSelectionTileGroup['layout'];
+  disabled: VegaSelectionTileGroup['disabled'];
   itemsController: VegaSelectionTileGroup['itemsController'];
   private groupContainerRef;
   getGroupContainerRef(): HTMLElement;
   render(): HTMLElement;
   private renderLabel;
-  private renderRequire;
   private renderContainer;
   private renderHint;
 }

package/dist/types/components/vega-selection-tile/vega-selection-tile-group/vega-selection-tile-group.d.ts

@@ -86,6 +86,16 @@ export declare class VegaSelectionTileGroup {
    * @vegaVersion 2.7.0
    */
   required: boolean;
+  /**
+   * 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.89.0
+   */
+  optional: boolean;
   /**
    * Indicates if the selection tile group is disabled.
    *

package/dist/types/components/vega-signature-capture/slimmers/written-mode/renderers/written-mode-renderer.d.ts

@@ -3,6 +3,7 @@ import { VegaSignatureCapture } from '../../../vega-signature-capture';
 export declare class WrittenModeRenderer extends VegaSlimmer {
   label: VegaSignatureCapture['label'];
   required: VegaSignatureCapture['required'];
+  optional: VegaSignatureCapture['optional'];
   showClearBtn: VegaSignatureCapture['showClearBtn'];
   placeholder: VegaSignatureCapture['placeholder'];
   placeholderIcon: VegaSignatureCapture['placeholderIcon'];

package/dist/types/components/vega-signature-capture/vega-signature-capture.d.ts

@@ -52,6 +52,16 @@ export declare class VegaSignatureCapture {
    * @vegaVersion 2.19.0
    */
   required: boolean;
+  /**
+   * 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.89.0
+   */
+  optional: boolean;
   /**
    * Determines whether the clear button is displayed.
    *

package/dist/types/components/vega-tab-group/slimmers/vega-tab-group/controllers/vega-tab-group-pages-controller.d.ts

@@ -81,8 +81,9 @@ export declare class VegaTabGroupPagesController extends PageResizeObserverSlimm
    */
   private emptySourceAndHiddenDropdown;
   /**
-   * 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.
    */
   private initTabsWidthArray;
 }

package/dist/types/components/vega-tab-group/vega-tab-group.d.ts

@@ -85,9 +85,10 @@ export declare class VegaTabGroup {
   /**
    * Defines the tab items that appear within the tab group.
    *
-   * The `tabItems` property can only be set once during
-   *    initialization and cannot be overridden or
-   *    modified dynamically.
+   * The `tabItems` property supports dynamic updates.
+   *
+   * - When items are added or removed, the tab group
+   *      will update tabs and overflow layout automatically.
    *
    * @vegaVersion 1.3.0
    */

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

@@ -2,12 +2,12 @@ import { VegaText } from '../../vega-text';
 import { PageResizeObserverSlimmer } from '../../../../helpers/slimmers/page-resize-observer-slimmer';
 /** The vega-text tooltip renderer slimmer */
 export declare class VegaTextTooltipRenderer extends PageResizeObserverSlimmer {
-  private static readonly DEFAULT_FONT_SIZE;
   host: VegaText['host'];
+  text: VegaText['text'];
   tooltip: VegaText['tooltip'];
   overflow: VegaText['overflow'];
   private tooltipRef;
-  private content;
+  private widthCheckerRef;
   /**
    * Component lifecycle - [componentDidLoad]{@link VegaText.componentDidLoad}
    */
@@ -18,6 +18,12 @@ export declare class VegaTextTooltipRenderer extends PageResizeObserverSlimmer {
    * @see{module:vega-text-restore-on-enlarge-screen-size}
    */
   constructor();
+  /**
+   * Watching the text prop — sync cached content and re-evaluate tooltip.
+   * The below method is e2e-test covered in
+   * @see{module:vega-text-with-dynamic-update-content}
+   */
+  watchText(): void;
   /**
    * The below method is e2e-test covered in
    * @see{module:vega-text-with-tooltip-placement}
@@ -31,22 +37,32 @@ export declare class VegaTextTooltipRenderer extends PageResizeObserverSlimmer {
    */
   private handleTooltip;
   /**
-   * The below method is e2e-test covered in
+   * Removes the tooltip from the DOM and restores plain text, regardless of hydration state.
+   *
    * @see{module:vega-text-with-long-text}
    * @see{module:vega-text-with-long-text-change-screen-size}
    */
-  private createTooltip;
-  /** Calculate the number of displayed characters according to the screen width and font size.
-   * In order to avoid errors, recalculate whether the vega-tooltip displays a line break.
-   * If it has, gradually reduce the number of calculated characters until there is no line break.
-   * If there is no newline yet, incrementally increase the counted number of characters until the newline.
-   * The below method is e2e-test covered in
+  private removeTooltip;
+  /**
+   * Update the tooltip display text.
+   *
    * @see{module:vega-text-with-long-text}
    * @see{module:vega-text-with-long-text-change-screen-size}
-   * @see{module:vega-text-with-long-text-minimize-screen-size}
-   * @see{module:vega-text-with-long-text-minimize-screen-safari}
    */
   private updateTooltipDisplayText;
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-text-with-long-text}
+   * @see{module:vega-text-with-long-text-change-screen-size}
+   */
+  private createTooltip;
+  /**
+   * Get the truncated text based on the available width and the font styles.
+   * If the truncated length is less than or equal to 1, it will set a min-width to prevent Safari from wrapping the text to multiple lines when the container is narrower than a single character.
+   *
+   * @see{module:vega-text-with-long-text}
+   */
+  private computeTruncatedText;
   /**
    * The below method is e2e-test covered in
    * @see{module:vega-text-with-long-text}
@@ -54,11 +70,17 @@ export declare class VegaTextTooltipRenderer extends PageResizeObserverSlimmer {
    * @see{module:vega-text-with-long-text-minimize-screen-size}
    */
   private truncateStringWithEllipsis;
-  private initTextContent;
   /**
    * Dynamically calculates and sets the minimum width of an element based on the content inside a hidden placeholder element.
    * The below method is e2e-test covered in
    * @see{module:vega-text-with-long-text-minimize-screen-safari}
    */
   private insertMinWidthStyle;
+  /**
+   * Check the maximum length of text that can be displayed without overflow based on the available width.
+   *
+   * @see {module:multiple-vega-text-in-flex-container}
+   * @returns {number} The maximum length of text that can be displayed without overflow.
+   */
+  private getSafeTextLengthByDom;
 }