@heartlandone/vega 2.80.0 → 2.82.0

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

@@ -577,21 +577,25 @@ export type RTERenderCustomAttributes = {
  */
 export type VegaRTETransformOptions = {
 	/**
-	 * If `true`, automatically match the format of the content to the RTE's internal format.
+	 * If `true`, automatically match the format of the content to the RTE's internal format. Not used in the toHtml method.
 	 */
 	autoMatchFormat?: boolean;
 	/**
-	 * If `true`, skip custom style, class and attribute when generating annotations from HTML elements.
+	 * If `true`, skip custom style, class and attribute when generating annotations from HTML elements. Not used in the toHtml method.
 	 */
 	skipCustomAnnotations?: boolean;
+	/**
+	 * If `true`, filter inline styles when converting to HTML or refill inline styles when converting from HTML. Used in fromHtml and toHtml methods.
+	 */
+	filterInlineStyles?: boolean;
 };
 
 /**
  * Configuration for source edit mode.
  */
-export type VegaRTESourceEditConfig = Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat'>> & {
-	// Other configurations can be added here as needed
-};
+export type VegaRTESourceEditConfig = Partial<
+	Pick<VegaRTETransformOptions, 'autoMatchFormat' | 'filterInlineStyles'>
+>;
 
 /**
  * Tokenized text node used for parsing.
@@ -713,6 +717,12 @@ export type VegaInlineHtmlSchema = {
 	 * Inline styles for the element.
 	 */
 	customStyle?: Record<string, string>;
+	/**
+	 * Grouping identifier — used at render time to merge adjacent text nodes
+	 * that share the same outer wrapper back into a single HTML element.
+	 * Assigned during fromHtml parsing.
+	 */
+	groupId?: string;
 };
 
 /**
@@ -889,3 +899,15 @@ export type RTETablePropertiesType = {
 	verticalAlign?: 'top' | 'middle' | 'bottom';
 	padding?: string;
 };
+
+export type RTEFilterInlineStylesResult = {
+	styles?: AnnotationStyle;
+	classNames?: string[];
+};
+
+export type VegaRTEGenerateStyleOptions = {
+	/**
+	 * If `true`, include font-face declarations for typography styles in the generated content style file.
+	 */
+	enableFontImports?: boolean;
+};

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

@@ -35,3 +35,4 @@ export { ElementToDTOStrategy } from './slimmers/controllers/helper/element-to-d
 export { BlockToRTEBlockStrategyAbstract } from './slimmers/controllers/helper/element-to-dto-strategy/block-to-rte-block-strategy.abstract';
 export { htmlElementToAnnotationGenerator };
 export { VegaRTEPresetToolbarItems } from './constants/constant';
+export { RTEFilterStylesStrategy } from './dto/filter-styles-strategies/filter-styles-strategy.abstract';

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/custom-style-annotation-handler.d.ts

@@ -18,11 +18,4 @@ export declare class CustomStyleAnnotationHandler extends AnnotationGeneratorStr
    * @returns {VegaRTETextAnnotations} - Annotation.
    */
   handle(element: HTMLElement): VegaRTETextAnnotations;
-  /**
-   * Obtain and format the style of element.
-   *
-   * @param {HTMLElement} element - current element.
-   * @returns {AnnotationStyle} - Record<string, string>.
-   */
-  private generateCustomStyleAnnotations;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator.d.ts

@@ -6,7 +6,7 @@ import { ClassPrototype } from '../../../../../../../types/class.type';
 export declare type RTEDtoClassPrototype = ClassPrototype<RTEBlock | RTENode>;
 export declare type HtmlElementToAnnotationGenerateOptions = {
   parentAnnotations?: VegaRTETextAnnotations;
-} & Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat' | 'skipCustomAnnotations'>>;
+} & Partial<Pick<VegaRTETransformOptions, 'autoMatchFormat' | 'skipCustomAnnotations' | 'filterInlineStyles'>>;
 /** Html element to annotations generator */
 declare class HtmlElementToAnnotationGenerator {
   private handlers;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/inline-html-annotation-handler.d.ts

@@ -5,7 +5,6 @@ import { VegaRTEAnnotations } from '../../../../../interface';
  * Handle inline html annotation
  */
 export declare class InlineHtmlAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
-  static canHandleTags: string[];
   private customAttributeHandler;
   private customStyleAnnotationHandler;
   private customClassAnnotationHandler;
@@ -25,4 +24,15 @@ export declare class InlineHtmlAnnotationHandler extends AnnotationGeneratorStra
    * @returns {Nullable<VegaInlineHtmlSchema>} - Inline html annotation.
    */
   private generateInlineHtmlAnnotation;
+  /**
+   * Immutably appends `toAppend` at the correct position in the chain — the
+   * deepest node whose `child.htmlTag` still matches `parentNode.nodeName`.
+   * Each level is reconstructed via spread so the original chain is never mutated.
+   *
+   * @param {VegaInlineHtmlSchema} node - Current chain node.
+   * @param {VegaInlineHtmlSchema} toAppend - Node to append at the tail.
+   * @param {ParentNode | null} parentNode - DOM parent of the element being processed.
+   * @returns {VegaInlineHtmlSchema} A new chain with `toAppend` inserted.
+   */
+  private appendToInlineHtmlChain;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/continue-inline-to-rte-text-block-strategy.d.ts

@@ -3,15 +3,10 @@ import { RTEContentBlock, VegaRTETransformOptions } from '../../../../interface'
 import { BlockToRTEBlockStrategyAbstract } from './block-to-rte-block-strategy.abstract';
 /** Transform continue inline block elements to text block DTO */
 export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBlockStrategyAbstract {
-  private static canHandleTags;
   /**
-   * Can be handle.
-   *
-   * @param {HTMLElement[]} elementsArray - Current elements.
-   * @param {number} currentIndex - Current element index.
-   * @returns {number} - can be handled element count.
+   * @inheritDoc
    */
-  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  canHandle(elementsArray: HTMLElement[], currentIndex: number, options: VegaRTETransformOptions): number;
   /**
    * Parse to a text block.
    *
@@ -37,4 +32,45 @@ export declare class ContinueInlineToRTETextBlockStrategy extends BlockToRTEBloc
    * @returns {Nullable<VegaRTETextBlockType>} - Block type.
    */
   private matchTextBlockTypeByTagName;
+  /**
+   * Check if the element is an inline candidate to be included in the text block.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @param {VegaRTETransformOptions} [options] - Options for transformation.
+   * @returns {boolean} - Whether the element is an inline candidate.
+   */
+  private isInlineCandidate;
+  /**
+   * Returns true when the tag has a dedicated block strategy (excludes inline annotation tags CODE and A).
+   *
+   * @param {string} nodeName - The node name to check.
+   * @returns {boolean} - Whether the tag is a dedicated block tag.
+   */
+  private isDedicatedBlockTag;
+  /**
+   * Returns true for empty elements, text-only elements, or elements whose entire
+   * descendant tree contains no block-level elements (e.g. {@code <u><i><b>text</b></i></u>}).
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} - Whether the element is an inline leaf or wrapper.
+   */
+  private isInlineLeafOrWrapper;
+  /**
+   * Returns true when the element has text-node children but no element children.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @returns {boolean} - Whether the element contains only text nodes.
+   */
+  private isTextOnlyElement;
+  /**
+   * Returns true if the element's subtree contains only inline formatting wrappers.
+   * Instead of maintaining a hard coded tag allowlist, the check derives from:
+   *  1. {@link DEDICATED_STRATEGY_TAGS} — rejects known block/media tags
+   *  2. Void-element check — elements with no child nodes (INPUT, COL, HR, …)
+   *     are replaced/embedded content, not formatting wrappers
+   *
+   * @param {HTMLElement} element - Element to inspect.
+   * @returns {boolean} True if the element has no block-level descendants.
+   */
+  private hasOnlyInlineDescendants;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy-processor.d.ts

@@ -11,10 +11,15 @@ declare class ElementToDtoStrategyProcessor {
    */
   process(elements: HTMLElement[], options?: VegaRTETransformOptions): ElementToDTOStrategyOutput[];
   /**
-   * Checks if the given element is valid to parse.
+   * Checks if the given element should be skipped during processing.
    *
-   * @param {HTMLElement} element - The pasted element.
-   * @returns {boolean} Is valid
+   * Comment nodes are always skipped. META and STYLE elements are skipped only
+   * in auto-match mode; in raw-HTML mode (autoMatchFormat: false) they are passed
+   * through so downstream strategies can decide how to handle them.
+   *
+   * @param {HTMLElement} element - The element to check.
+   * @param {VegaRTETransformOptions} options - Transform options.
+   * @returns {boolean} True when the element should be skipped.
    */
   private isInvalidElement;
   /**

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/html-block-strategy.d.ts

@@ -6,7 +6,6 @@ import { RTEHtmlBlock } from '../../../../dto/blocks/html-block';
  * Converting HTML block elements into RTE blocks.
  */
 export declare class HtmlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
-  private static canHandleTags;
   /**
    * @inheritDoc
    */
@@ -23,6 +22,40 @@ export declare class HtmlBlockStrategy extends BlockToRTEBlockStrategyAbstract {
    * @inheritDoc
    */
   shouldProceedToElementChildren(): boolean;
+  /**
+   * Returns true for elements that should be treated as inline content even if they have no element children (e.g. <span>text</span>).
+   * This includes any element in a block text context (P, H1-H6, LI) and any element with text-node children but no element-node children.
+   *
+   * In raw-HTML mode (autoMatchFormat: false), the text-only heuristic only
+   * applies to elements whose parent is itself a text-only wrapper (e.g.
+   * {@code <div><span>Title</span></div>}). Structural children of non-text
+   * containers (TABLE → CAPTION, TR → TH/TD, etc.) skip this heuristic so
+   * they reach {@link isCustomHtmlContainer} and become html-blocks.
+   *
+   * @param {HTMLElement} element - Element to check.
+   * @param {VegaRTETransformOptions} options - Transform options.
+   * @returns {boolean} True if the element should be treated as inline content.
+   */
+  private isInlineTagWithoutBlockChildren;
+  /**
+   * Returns true when a dedicated-strategy element should fall back to html-block
+   * because all its children are non-text, non-inline, non-dedicated elements
+   * — indicating purely block-level embedded content that the dedicated text-block
+   * strategy cannot represent.
+   *
+   * @param {HTMLElement} element - The dedicated-strategy element to check.
+   * @returns {boolean} True when the element should be treated as html-block.
+   */
+  private shouldFallBackToHtmlBlock;
+  /**
+   * Returns true for elements that should be treated as html containers.
+   * A DIV is only a valid container when its first child is not an IMG
+   * (IMG children are handled by the image strategy instead).
+   *
+   * @param {HTMLElement} element - Element to check.
+   * @returns {boolean} True if the element qualifies as a html container.
+   */
+  private isCustomHtmlContainer;
   /**
    * Generate HTML block DTO from an HTML element.
    *

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/predicate.d.ts

@@ -0,0 +1,21 @@
+import { TextStyleAnnotationHandler } from './annotation-handler/text-style-annotation-handler';
+/**
+ * Predicate class provides static methods to check specific conditions on HTML elements.
+ */
+export declare class Predicate {
+  static textStyleHandler: TextStyleAnnotationHandler;
+  /**
+   * Checks if the given element is a title or subtitle.
+   *
+   * @param {HTMLElement} element The element to check.
+   * @returns {boolean} True if the element is a title or subtitle, false otherwise.
+   */
+  static isTitleOrSubtitle(element: HTMLElement): boolean;
+  /**
+   * Check if the given element is a link element (anchor tag).
+   *
+   * @param {HTMLElement} element The element to check.
+   * @returns {boolean} True if the element is a link element, false otherwise.
+   */
+  static isLinkElement(element: HTMLElement): boolean;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/strategy-tags.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Tags whose direct children are always phrasing (inline) content (P, H1-H6, LI).
+ *
+ * This is spec knowledge from the HTML Living Standard — these grouping-content
+ * elements have a phrasing-content content model and cannot contain block-level
+ * descendants. It cannot be derived from the strategy registry and must be
+ * maintained alongside the HTML spec.
+ *
+ * @see https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+ */
+export declare const BLOCK_TEXT_CONTAINER_TAGS: Set<string>;
+/**
+ * Tags with dedicated element-to-DTO block strategies
+ * (P, H1-H6, LI, UL, OL, IMG, CODE).
+ *
+ * HtmlBlockStrategy skips these to avoid double-processing or overriding their
+ * specialized block semantics.
+ *
+ * Why hard-coded: strategies use heterogeneous matching (`tagName ===`,
+ * `matchTextBlockType` via font-size/class, etc.) so there is no single
+ * declarative contract to derive this set from. It must be kept in sync with
+ * the strategies registered in `dto/setup.ts`.
+ *
+ * Intentionally independent of {@link BLOCK_TEXT_CONTAINER_TAGS} — the two
+ * sets encode different concepts (app architecture vs. HTML spec) and must
+ * be maintained separately.
+ */
+export declare const DEDICATED_STRATEGY_TAGS: Set<string>;
+/**
+ * Tags that are always treated as phrasing (inline) content, even when they
+ * also appear in {@link DEDICATED_STRATEGY_TAGS} (CODE).
+ * A tag in this set overrides the dedicated-strategy skip in HtmlBlockStrategy.
+ *
+ * Mix of HTML5 spec phrasing-content elements (BR, CODE, A) and
+ * RTE-internal custom elements (VEGA-RICH-TEXT-LINK-EDITOR).
+ */
+export declare const ALWAYS_INLINE_TAGS: Set<string>;
+/**
+ * Tags whose content model requires each child to be a distinct block-level
+ * element (table model and definition list).
+ *
+ * TABLE expects CAPTION/THEAD/TBODY/TFOOT/TR; TR expects TH/TD;
+ * THEAD/TBODY/TFOOT expect TR; DL expects DT/DD.
+ *
+ * Used by HtmlBlockStrategy to prevent text-only children (e.g. CAPTION,
+ * TH, TD) from being treated as inline — they must become html-blocks so
+ * the table structure round-trips correctly.
+ *
+ * Note: COLGROUP is intentionally excluded. Its only permitted child is the
+ * void element COL, which can never produce text-node children, so the
+ * text-only heuristic in HtmlBlockStrategy can never fire for a COLGROUP
+ * parent.
+ *
+ * @see https://html.spec.whatwg.org/multipage/tables.html#the-table-element
+ * @see https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element
+ */
+export declare const STRUCTURED_CONTAINER_TAGS: Set<string>;
+/**
+ * Formatting phrasing-content elements that CAN remain inline even when empty.
+ *
+ * Any element NOT in this set (DIV, SECTION, ARTICLE, custom elements, etc.)
+ * is treated as a block separator. Phrasing content is a closed, finite set
+ * per the HTML Living Standard, making an allowlist safer than blocklisting
+ * block containers (which is open-ended — custom elements default to block).
+ *
+ * Intentionally excludes:
+ * - BR, CODE, A, VEGA-RICH-TEXT-LINK-EDITOR → handled by {@link ALWAYS_INLINE_TAGS}
+ * - P, H1-H6, LI, UL, OL, IMG → handled by {@link DEDICATED_STRATEGY_TAGS}
+ * - VIDEO, AUDIO, EMBED → embedded content that carries media even when empty;
+ *   must be treated as block-level, not as inline formatting artifacts
+ *
+ * @see https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+ */
+export declare const PHRASING_CONTENT_TAGS: Set<string>;
+/**
+ * Returns true when the element is a direct child of a block text container
+ * (P, H1-H6, LI), meaning it must be treated as phrasing content regardless
+ * of its own DOM structure.
+ *
+ * @param {HTMLElement} element - Element to test.
+ * @returns {boolean} True if the element is inside a block text container.
+ */
+export declare function isInBlockTextContext(element: HTMLElement): boolean;

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

@@ -34,4 +34,10 @@ export declare class VegaRichTextEditorSourceViewRenderer extends VegaSlimmer {
    * Handle the blur event of the code block. When the code block loses focus, emit the source code change event with the current source code.
    */
   private handleCodeBlockBlur;
+  /**
+   * Get the source view template string based on the current value of the rich text editor.
+   *
+   * @returns {string} The HTML template string
+   */
+  private getSourceTemplate;
 }

package/dist/types/components/vega-section-title/slimmers/renderers/vega-section-title-renderer.d.ts

@@ -6,6 +6,8 @@ export declare class VegaSectionTitleRenderer extends VegaSlimmer {
   description: VegaSectionTitle['description'];
   icon: VegaSectionTitle['icon'];
   iconAlign: VegaSectionTitle['iconAlign'];
+  iconColor: VegaSectionTitle['iconColor'];
+  size: VegaSectionTitle['size'];
   render(): HTMLElement;
   private renderPrefixIcon;
   private renderText;

package/dist/types/components/vega-section-title/types.d.ts

@@ -0,0 +1 @@
+export type VegaSectionTitleSizeType = 'default' | 'small';

package/dist/types/components/vega-section-title/vega-section-title.d.ts

@@ -1,6 +1,8 @@
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
 import { VegaSectionTitleRenderer } from './slimmers/renderers/vega-section-title-renderer';
 import { IconAlignType } from '../../types/ui.type';
+import { TextColorsTokenType } from '../../types/design-token.type';
+import { VegaSectionTitleSizeType } from './types';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
  * @vegaVersion 2.1.0
@@ -37,5 +39,17 @@ export declare class VegaSectionTitle {
    * @vegaVersion 2.1.0
    */
   iconAlign: IconAlignType;
+  /**
+   * Specifies the color of the icon displayed
+   *    within the section title.
+   * @vegaVersion 2.81.0
+   */
+  iconColor: TextColorsTokenType;
+  /**
+   * Specifies the size of the section title.
+   *
+   * @vegaVersion 2.81.0
+   */
+  size: VegaSectionTitleSizeType;
   render(): VegaSectionTitle;
 }

package/dist/types/components/vega-table/slimmers/controllers/vega-table-render-input-controller.d.ts

@@ -19,6 +19,7 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
   private headRowRenderInputMap;
   private headCellRenderInputMap;
   private pinnedColumnBodyCellRenderInputMap;
+  private cellRenderInputChangeTaskQueue;
   /**
    * Register remote invocation observers when controller is connected.
    * Called via component lifecycle mapping.
@@ -34,11 +35,17 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    * Called via component lifecycle mapping.
    */
   componentWillLoad(): void;
+  /**
+   * Notify body cells about render input changes after the table has re-rendered.
+   * This ensures ref callbacks have fired and the pinnedColumnBodyCellRenderInputMap is up-to-date.
+   * Called via component lifecycle mapping.
+   */
+  componentDidRender(): Promise<void>;
   /**
    * Recompute head context when the column structure model changes.
    * Called via watch mapping.
    */
-  watchColumnStructureModel(): void;
+  watchColumnStructureModel(): Promise<void>;
   /**
    * Return render input models for table body (flattened leaves).
    *

package/dist/types/components/vega-table/slimmers/renderers/vega-table-pinned-renderer.d.ts

@@ -7,12 +7,16 @@ export declare class VegaTablePinnedRenderer extends VegaSlimmer {
   paddingX: VegaTable['paddingX'];
   vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
+  private previouslyStyledCells;
+  private clearPinnedPositionsTaskQueue;
   componentDidLoad(): void;
-  componentDidRender(): void;
+  componentDidRender(): Promise<void>;
+  watchColumnStructureModel(): void;
   private updateTableCellPinnedPosition;
   private getRowShadowThWidths;
   private getLeafWidths;
   private updateCellPinnedPosition;
   private updateTableRowPinnedPosition;
+  private clearAllPinnedPositions;
   private updatePinnedPosition;
 }

package/dist/types/components/vega-table/vega-table-cell/vega-table-cell.d.ts

@@ -6,6 +6,9 @@ import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize
 import { GlobalSlimmers } from '../../../vega-slimmer/vega-slimmer-core';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
 import { VegaTableRowStateSubscriber } from './slimmers/controllers/vega-table-row-state-subscriber';
+import { ColumnRenderInputModel } from '../slimmers/controllers/dto/column-render-input-model';
+import { Nullable } from '../../../types/general';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
 /**
  * @vegaVersion 1.44.0
  */
@@ -15,6 +18,7 @@ export declare class VegaTableCell {
   protected readonly vegaTableRowStateSubscriber: VegaTableRowStateSubscriber;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableCellElement>;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   host: HTMLVegaTableCellElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
@@ -27,6 +31,7 @@ export declare class VegaTableCell {
   checked?: boolean;
   striped?: boolean;
   expanded?: boolean;
+  renderInput: Nullable<ColumnRenderInputModel>;
   /**
    * Determines the alignment of text within the cell.
    *

package/dist/types/components/vega-table/vega-table-head-cell/vega-table-head-cell.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from '../../../stencil-public-runtime';
 import { VegaTableColumnBreakpoint, VegaTableDensityType, VegaTableHeadCellClickEvent, VegaTablePinnedType, VegaTableSortConfig, VegaTableSorterConfig, VegaTableSortOrderType } from '../interface';
+import { Nullable } from '../../../types/general';
 import { EventEmitSlimmerBase } from '../../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { GlobalSlimmers } from '../../../vega-slimmer/vega-slimmer-core';
 import { ResponsiveType } from '../../../types/ui.type';
@@ -9,6 +10,8 @@ import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
 import { SortIconRenderer } from './slimmers/renderers/sort-icon-renderer';
 import { VegaTableHeadCellSortConfigController } from './slimmers/controllers/vega-table-head-cell-sort-config-controller';
+import { ColumnRenderInputModel } from '../slimmers/controllers/dto/column-render-input-model';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
 /**
  * @vegaVersion 1.44.0
  */
@@ -20,6 +23,7 @@ export declare class VegaTableHeadCell {
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableHeadCellElement>;
   protected sortIconRenderer: SortIconRenderer;
   protected readonly vegaTableHeadCellSortConfigController: VegaTableHeadCellSortConfigController;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   host: HTMLVegaTableHeadCellElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
@@ -27,6 +31,7 @@ export declare class VegaTableHeadCell {
    */
   density?: ResponsiveType<VegaTableDensityType>;
   columnDivider?: boolean;
+  renderInput: Nullable<ColumnRenderInputModel>;
   /**
    * Defines the screen width at which the column becomes hidden.
    *    If not set, the column remains visible at all times.

package/dist/types/components/vega-table/vega-table-head-row/slimmers/renderers/vega-table-head-row-renderer.d.ts

@@ -10,6 +10,7 @@ export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   expandable: VegaTableHeadRow['expandable'];
   isEmptyTable: VegaTableHeadRow['isEmptyTable'];
   isTemplateRenderMode: VegaTableHeadRow['isTemplateRenderMode'];
+  renderInput: VegaTableHeadRow['renderInput'];
   /**
    * Used by {@link currentDataObserver}
    */

package/dist/types/components/vega-table/vega-table-head-row/vega-table-head-row.d.ts

@@ -1,5 +1,6 @@
 import { GlobalSlimmers } from '../../../vega-slimmer/vega-slimmer-core';
 import { Nullable } from '../../../types/general';
+import { ColumnRenderInputModel } from '../slimmers/controllers/dto/column-render-input-model';
 import { VegaTableHeadRowRenderer } from './slimmers/renderers/vega-table-head-row-renderer';
 import { VegaTableHeadRowController } from './slimmers/controllers/vega-table-head-row-controller';
 import { VegaTableHeadRowStateController } from './slimmers/controllers/vega-table-head-row-state-controller';
@@ -9,6 +10,7 @@ import { VegaTableDensityType } from '../interface';
 import { BreakpointsTokenType } from '../../../types/design-token.type';
 import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize-observer-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
 /**
  * @vegaVersion 1.44.0
  */
@@ -20,6 +22,7 @@ export declare class VegaTableHeadRow {
   protected headCellEventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableHeadRowElement>;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   host: HTMLVegaTableHeadRowElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
@@ -54,6 +57,7 @@ export declare class VegaTableHeadRow {
    * Whether the parent table is template render mode
    */
   isTemplateRenderMode: boolean;
+  renderInput: Nullable<ColumnRenderInputModel[]>;
   /**
    * Indicates whether the checkbox is disabled.
    *

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

@@ -1,7 +1,9 @@
 /**
  * Configuration properties for the tooltip used by the text component.
  *
- * Only the `placement` property from the underlying
- * `HTMLVegaTooltipElement` is exposed.
+ * Only the `placement`, `maxWidth`, and `minWidth` properties from the underlying
+ * `HTMLVegaTooltipElement` are exposed.
  */
-export type VegaTextTooltipProps = Partial<Pick<HTMLVegaTooltipElement, 'placement'>>;
+export type VegaTextTooltipProps = Partial<
+	Pick<HTMLVegaTooltipElement, 'placement' | 'maxWidth' | 'minWidth'>
+>;

package/dist/types/components/vega-tooltip/vega-tooltip-content-box/vega-tooltip-content-box.d.ts

@@ -10,6 +10,10 @@ export declare class VegaTooltipContentBox {
   /**
    * Specifies the text that is displayed inside the tooltip.
    *
+   * Line breaks (`\n`) are supported and rendered as new lines. Consecutive
+   * regular spaces are collapsed; to preserve indentation (e.g. hanging indent
+   * for bullet lists) use the non-breaking space character `\u00A0`.
+   *
    * @vegaVersion 2.0.0
    */
   text: string;

package/dist/types/components/vega-tooltip/vega-tooltip.d.ts

@@ -66,6 +66,10 @@ export declare class VegaTooltip {
    * Specifies the text that is displayed
    *    inside the tooltip.
    *
+   * Line breaks (`\n`) are supported and rendered as new lines. Consecutive
+   * regular spaces are collapsed; to preserve indentation (e.g. hanging indent
+   * for bullet lists) use the non-breaking space character `\u00A0`.
+   *
    * @vegaVersion 2.0.0
    */
   text: string;