@heartlandone/vega 2.82.0 → 2.84.0

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

@@ -96,17 +96,16 @@ export declare class VegaProgressTracker {
    */
   canClickStep: boolean;
   /**
-   * When enabled, allows `current` to be set to `-1` to indicate
-   *    no highlighted/current step (e.g. all steps are pending or
-   *    the workflow has not started).
+   * When enabled, `current = -1` becomes a valid state that indicates
+   *    no highlighted/current step (e.g. all steps are pending or the
+   *    workflow has not started).
    *
-   * Defaults to `false` to preserve backward-compatible behavior:
-   *    `current` is clamped to `[0, steps.length - 1]`.
+   * Two ways to enter this state:
+   * - Set the `current` prop to `-1`.
+   * - Call the `setCurrent(-1)` method.
    *
-   * When enabled, `current = -1` is a valid state. The `prevStep()`
-   *    method still clamps at `0` — reaching `-1` is only possible
-   *    by explicitly setting `current = -1` via the prop or
-   *    `setCurrent(-1)`.
+   * @VegaHint `prevStep()` still clamps at `0` and will not take `current`
+   *    into `-1`.
    *
    * @vegaVersion 2.82.0
    */

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-style-annotation.d.ts

@@ -1,13 +1,6 @@
 import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
 import { AnnotationStyle, RTERenderContext, VegaRTETextStyleType } from '../../interface';
 import { Nullable } from '../../../../types/general';
-export declare type RTETextStyleBaseType = {
-  fontFamily: string;
-  fontWeight: string;
-  fontSize: string;
-  lineHeight: string;
-  minHeight: string;
-};
 /**
  * Text style annotation
  */

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-style-default-styles.d.ts

@@ -0,0 +1,3 @@
+import { AnnotationStyle, VegaRTETextStyleType } from '../../interface';
+export declare const TEXT_STYLE_VALUES: VegaRTETextStyleType[];
+export declare const TEXT_STYLE_DEFAULTS: Record<VegaRTETextStyleType, AnnotationStyle>;

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

@@ -45,12 +45,25 @@ export declare abstract class VegaRTEExtension {
    * @param {RTEFilterStylesStrategy} strategy - The filter styles strategy to register.
    */
   static registerFilterStylesStrategy(blockOrNodeClassName: string, strategy: RTEFilterStylesStrategy): void;
+  /**
+   * Lifecycle hook called by the rich text editor before the first render
+   * (during `componentWillLoad`).  Override this method to perform per-host
+   * pre-render setup — for example, registering a host-specific toolbar button
+   * renderer via {@link registerToolbarButtonRenderer} so that each editor on
+   * the page gets its own isolated renderer instance.
+   *
+   * The default implementation is a no-op; subclasses may override selectively.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {HTMLVegaRichTextEditorElement} host - The host rich text editor element that is about to load.
+   */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
   /**
    * Initializes the RTE extension with the provided context.
    *
    * @param {RTEExtensionContext} context - The context of the RTE extension.
    */
-  initialExtension(context: RTEExtensionContext): void;
+  initialExtensionAfterLoad(context: RTEExtensionContext): void;
   /**
    * Callback method invoked when the extension is destroyed.
    * Override this method to perform any necessary cleanup.
@@ -79,11 +92,16 @@ export declare abstract class VegaRTEExtension {
   protected registerRenderer(type: string, renderer: BaseRenderer): void;
   /**
    * Register a toolbar button renderer for the extension.
+   * When a `host` element is provided the renderer is registered in the per-host map
+   * (via {@link RTEDTORendererManager#registerRTEToolbarButtonRendererForHost}), giving
+   * that host an isolated renderer instance that takes precedence over the global singleton.
+   * Omit `host` to fall back to the global registration (backwards-compatible default).
    *
    * @param {string} type - The type of the toolbar button.
    * @param {VegaRTEToolbarButtonRenderer} renderer - The renderer to register.
+   * @param {HTMLVegaRichTextEditorElement} [host] - Optional host element for per-host isolation.
    */
-  protected registerToolbarButtonRenderer(type: string, renderer: VegaRTEToolbarButtonRenderer): void;
+  protected registerToolbarButtonRenderer(type: string, renderer: VegaRTEToolbarButtonRenderer, host?: HTMLVegaRichTextEditorElement): void;
   /**
    * This is a helper method that utilizes RTEUtils to register common strategies.
    * Call the method with the class name of the block to make it support basic strategies like:

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

@@ -6,15 +6,26 @@ import { VegaRTEExtension } from '../extension.abstract';
  */
 export declare class VegaRTELanguageExtension extends VegaRTEExtension {
   private languageToolbarButtonRenderer;
+  private readonly languageList;
   private languageState;
   constructor(languageList: (RTEDropdownListItem | RTEDropdownListGroup)[], languagesState?: RTELanguageExtensionState);
+  /**
+   * Called by the rich text editor during `componentWillLoad` (before the first render).
+   * Creates a fresh {@link RTELanguageToolbarButtonRenderer} instance dedicated to this
+   * host element and registers it in the per-host map inside {@link RTEDTORendererManager}.
+   * This ensures that each editor on the page has its own isolated renderer — no shared
+   * singleton state, no WeakMap indirection.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {HTMLVegaRichTextEditorElement} host - The host rich text editor element.
+   */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
   /**
    * Initializes the language extension.
-   * Applies the content for the selected language upon initialization.
    *
    * @param {RTEExtensionContext} context The extension context.
    */
-  initialExtension(context: RTEExtensionContext): void;
+  initialExtensionAfterLoad(context: RTEExtensionContext): void;
   /**
    * Invoked to set the language extension state. The method used if the state can not be provide when the editor is initialized.
    *

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

@@ -3,15 +3,23 @@ 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.
  */
 export declare class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
   private languageList;
+  private languageChangeCallback;
   private selectedLanguage;
   private labelRef;
-  private languageChangeCallback;
-  constructor(languageList: (RTEDropdownListItem | RTEDropdownListGroup)[], languageChangeCallback: LanguageSelectedCallback, selectedLanguage: string);
+  constructor(languageList: (RTEDropdownListItem | RTEDropdownListGroup)[], languageChangeCallback: LanguageSelectedCallback, selectedLanguage?: string);
   /**
-   * Public method to set the selected language.
+   * Updates the selected language and refreshes the button label text in-place,
+   * without requiring a full re-render of the toolbar.
    *
    * @param {string} language The language key to set as selected.
    */
@@ -27,7 +35,8 @@ export declare class RTELanguageToolbarButtonRenderer extends VegaRTEToolbarButt
    */
   render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
   /**
-   * Override to render the button label with custom behavior.
+   * Override to capture the rendered label element ref so that
+   * {@link setSelectedLanguage} can update the button text without a full re-render.
    *
    * @inheritDoc
    */
@@ -40,6 +49,8 @@ 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.
    *
    * @param {string} itemKey - The key of the selected language item.
    */

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

@@ -28,7 +28,7 @@ export declare class VegaRTETableExtension extends VegaRTEExtension {
    *
    * @param {RTEExtensionContext} context - extension context
    */
-  initialExtension(context: RTEExtensionContext): void;
+  initialExtensionAfterLoad(context: RTEExtensionContext): void;
   /**
    * @inheritDoc
    */

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

@@ -59,6 +59,10 @@ export type VegaRTETextStyleType =
 	| 'heading-5'
 	| 'heading-6';
 
+export type VegaRTETextStyleItem = {
+	key: VegaRTETextStyleType;
+};
+
 /**
  * Heading block variants used in the editor.
  */

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/extension-controller.d.ts

@@ -10,6 +10,13 @@ export declare class RTEExtensionController extends VegaSlimmer {
   protected sourceView: VegaRichTextEditor['sourceView'];
   protected valueController: VegaRichTextEditor['valueController'];
   protected selectionController: VegaRichTextEditor['selectionController'];
+  /**
+   * Prepares all registered extensions before the first render.
+   * This method is called during `componentWillLoad` so that extensions can perform
+   * host-specific setup (e.g. registering per-host toolbar button renderers) before
+   * Stencil renders the component for the first time.
+   */
+  protected prepareExtensionsBeforeLoad(): void;
   /**
    * Initializes the extension context for all registered extensions.
    * This method is called when the component is connected and whenever the extensions property changes.

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/image-toolbar-button-slimmer.d.ts

@@ -11,6 +11,7 @@ export declare type InsertURLForm = {
 };
 export declare class ImageToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
   private static readonly items;
+  protected host: VegaRichTextEditor['host'];
   protected insertImageController: VegaRichTextEditor['insertImageController'];
   protected imageInsertedEventEmitter: VegaRichTextEditor['imageInsertedEventEmitter'];
   protected selectionController: VegaRichTextEditor['selectionController'];

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/text-styles-toolbar-button-slimmer.d.ts

@@ -1,16 +1,17 @@
 import { ToolbarInternalButtonConfig } from './toolbar-button-slimmer.abstract';
 import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 import { VisualModeToolbarButtonSlimmer } from './visual-mode-toolbar-button-slimmer.abstract';
-export declare type TextStyleType = 'title' | 'subtitle' | 'paragraph' | 'heading-1' | 'heading-2' | 'heading-3';
+import { VegaRTETextStyleType } from '../../../interface';
 export declare type TextStyleItem = {
-  key: TextStyleType;
+  key: VegaRTETextStyleType;
   label: string;
   bold?: boolean;
 };
 export declare class TextStylesToolbarButtonSlimmer extends VisualModeToolbarButtonSlimmer {
-  private static readonly items;
+  private static readonly allItems;
   selectionController: VegaRichTextEditor['selectionController'];
   focusController: VegaRichTextEditor['focusController'];
+  textStyleItems: VegaRichTextEditor['textStyleItems'];
   constructor();
   protected renderBtnWrapper(renderBtn: (toolbarInternalButton: ToolbarInternalButtonConfig) => HTMLElement): HTMLElement;
   protected renderDropdownContent(): HTMLElement;

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

@@ -2,7 +2,7 @@ import { EventEmitter } from '../../stencil-public-runtime';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { VegaRichTextEditorRenderer } from './slimmers/renderers/vega-rich-text-editor-renderer';
-import { VegaRTEContentBlock, VegaRichTextEditorImage, VegaRTESourceEditConfig } from './interface';
+import { VegaRTEContentBlock, VegaRichTextEditorImage, VegaRTESourceEditConfig, VegaRTETextStyleItem } from './interface';
 import { ToolbarRenderer } from './slimmers/renderers/toolbar-renderer';
 import { BoldToolbarButtonSlimmer } from './slimmers/renderers/tools/bold-toolbar-button-slimmer';
 import { ItalicToolbarButtonSlimmer } from './slimmers/renderers/tools/italic-toolbar-button-slimmer';
@@ -190,6 +190,19 @@ export declare class VegaRichTextEditor {
    */
   validationRules: FormFieldValidationRule<unknown>[];
   watchValidationRules(): void;
+  /**
+   * Specifies which text style items appear in the Text Styles toolbar dropdown.
+   *
+   * Use this to control which heading levels and text styles are available to users.
+   * For example, omit `{ key: 'heading-1' }` to prevent users from applying H1
+   * (which is typically reserved for the page title).
+   *
+   * Items are displayed in a fixed internal order regardless of the order in this array.
+   *
+   * @vegaVersion 2.83.0
+   * @defaultValue [{ key: 'title' }, { key: 'subtitle' }, { key: 'heading-1' }, { key: 'heading-2' }, { key: 'heading-3' }, { key: 'paragraph' }]
+   */
+  textStyleItems: VegaRTETextStyleItem[];
   /**
    * Specifies the configuration for the rich text editor extensions.
    *

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

@@ -15,6 +15,7 @@ export declare class VegaTextTooltipRenderer extends PageResizeObserverSlimmer {
   /**
    * The below method is e2e-test covered in
    * @see{module:vega-text-with-long-text-change-screen-size}
+   * @see{module:vega-text-restore-on-enlarge-screen-size}
    */
   constructor();
   /**

package/dist/types/components/vega-time-picker/slimmers/renderers/vega-time-picker-range-clear-button-renderer.d.ts

@@ -3,6 +3,7 @@ import { VegaTimePicker } from '../../vega-time-picker';
 export declare class VegaTimePickerRangeClearButtonRenderer extends VegaSlimmer {
   disabled: VegaTimePicker['disabled'];
   value: VegaTimePicker['value'];
+  showClearIcon: VegaTimePicker['showClearIcon'];
   valueController: VegaTimePicker['valueController'];
   endDropdownController: VegaTimePicker['endDropdownController'];
   rangeInputRenderer: VegaTimePicker['rangeInputRenderer'];
@@ -10,9 +11,11 @@ export declare class VegaTimePickerRangeClearButtonRenderer extends VegaSlimmer
   /** The `onClickClearIcon` function is a private method that is called when the clear icon is clicked. It performs the following actions: */
   private onClickClearIcon;
   /**
-   * The function checks if the value is an array and if either of the elements in the array is truthy, returning true if so.
+   * Determines whether the range clear button should be visible. The button
+   * is shown only when the clear icon feature is enabled, the component is
+   * not disabled, and at least one end of the range value is non-empty.
    *
-   * @returns {boolean} a boolean value.
+   * @returns {boolean} `true` when the clear button should be visible.
    */
-  private isInvisible;
+  private shouldShowClearButton;
 }

package/dist/types/components/vega-time-picker/slimmers/renderers/vega-time-picker-single-input-renderer.d.ts

@@ -9,6 +9,7 @@ export declare class VegaTimePickerSingleInputRenderer extends VegaSlimmer {
   private singleDropdownController;
   private translationSlimmer;
   private readOnly;
+  private showClearIcon;
   private timeInputRef;
   /**
    * The function returns a reference to an HTML input element.

package/dist/types/components/vega-time-picker/vega-time-picker.d.ts

@@ -148,6 +148,26 @@ export declare class VegaTimePicker {
    * @vegaVersion 2.79.0
    */
   readOnly: boolean;
+  /**
+   * Controls whether a clear (✕) icon button is displayed inside the time
+   * picker input when the field has a non-empty value.
+   *
+   * When `true`, clicking the clear icon resets the time picker value to an
+   * empty value (or `['', '']` in `range` mode) and emits a `vegaChange`
+   * event. Set to `false` to hide the clear icon (e.g., for time pickers
+   * where clearing is not desired).
+   *
+   * The clear icon is also hidden when the component is `disabled`.
+   *
+   * When the component is `readOnly`, the clear icon remains visible by
+   * design: read-only only suppresses manual keyboard text entry, while
+   * users can still update the value via the dropdown UI, so clearing the
+   * selected value is still a valid interaction.
+   *
+   * @default true
+   * @vegaVersion 2.84.0
+   */
+  showClearIcon: boolean;
   /**
    * Specifies the validation status of the time picker component.
    *