@globalpayments/vega 2.87.0 → 2.88.0

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

@@ -9,6 +9,8 @@ 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';
+const patchedBlockClasses = new WeakSet();
+const annotationHandlersByClass = new WeakMap();
 /**
  * Abstract class for Vega Rich Text Editor extensions.
  */
@@ -49,6 +51,53 @@ export class VegaRTEExtension {
   static registerFilterStylesStrategy(blockOrNodeClassName, strategy) {
     RTEFilterStylesStrategyRegistry.register(blockOrNodeClassName, strategy);
   }
+  /**
+   * Attach a custom JSON annotation handler to a block DTO class's static `from` flow.
+   *
+   * This is a reusable extension point: any extension can register a handler for an
+   * annotation key and transform the value into block annotations during JSON parsing.
+   *
+   * Safe to call multiple times per class/key/handler — duplicate registrations are no-ops.
+   *
+   * @param {BlockClassWithFrom} BlockClass - Block DTO class to patch.
+   * @param {string} annotationKey - JSON annotation key to read from `block.annotations`.
+   * @param {AnnotationFromJsonHandler} handler - Handler that applies annotation logic to the instance.
+   */
+  static attachAnnotationFromJson(BlockClass, annotationKey, handler) {
+    var _a, _b;
+    const handlerMap = (_a = annotationHandlersByClass.get(BlockClass)) !== null && _a !== void 0 ? _a : new Map();
+    const handlers = (_b = handlerMap.get(annotationKey)) !== null && _b !== void 0 ? _b : new Set();
+    handlers.add(handler);
+    handlerMap.set(annotationKey, handlers);
+    annotationHandlersByClass.set(BlockClass, handlerMap);
+    if (patchedBlockClasses.has(BlockClass)) {
+      return;
+    }
+    patchedBlockClasses.add(BlockClass);
+    const originalFrom = BlockClass.from.bind(BlockClass);
+    /**
+     * Wrapped static `from` that preserves original behavior and then applies
+     * all registered annotation-from-json handlers for this BlockClass.
+     *
+     * @param {VegaRTEBlockBase} block - Raw JSON block payload.
+     * @param {VegaRTETransformOptions} [options] - Optional transform options.
+     * @returns {RTEBlock} The transformed block instance.
+     */
+    BlockClass.from = function patchedFrom(block, options) {
+      const instance = originalFrom(block, options);
+      const annotations = block.annotations;
+      const currentHandlerMap = annotationHandlersByClass.get(BlockClass);
+      if (annotations && currentHandlerMap) {
+        currentHandlerMap.forEach((registeredHandlers, key) => {
+          const value = annotations[key];
+          registeredHandlers.forEach((registeredHandler) => {
+            registeredHandler(instance, value, block, options);
+          });
+        });
+      }
+      return instance;
+    };
+  }
   /**
    * Lifecycle hook called by the rich text editor before the first render
    * (during `componentWillLoad`).  Override this method to perform per-host
@@ -71,7 +120,7 @@ export class VegaRTEExtension {
    */
   initialExtensionAfterLoad(context) {
     this.extensionContext = context;
-    rteExtensionContextManager.setExtensionContext(context);
+    rteExtensionContextManager.updateExtensionContext(context);
   }
   /**
    * Callback method invoked when the extension is destroyed.

package/dist/collection/components/vega-rich-text-editor/extensions/functions/dto/function-block.js

@@ -8,6 +8,7 @@ import { RTETextBlock } from '../../../dto/blocks/text-block';
 export class RTEFunctionBlock extends RTEBlock {
   constructor(id) {
     super(id);
+    this.dtoName = RTEFunctionBlock.dtoName;
     this.type = 'function-block';
     this.children = [];
   }
@@ -95,3 +96,4 @@ export class RTEFunctionBlock extends RTEBlock {
     return styles ? ` style="${styles}"` : '';
   }
 }
+RTEFunctionBlock.dtoName = 'RTEFunctionBlock';

package/dist/collection/components/vega-rich-text-editor/extensions/functions/dto/logic-control-block.js

@@ -6,6 +6,7 @@ import { RTELogicControlNode } from '../dto/logic-control-node';
 export class RTELogicControlBlock extends RTEBlock {
   constructor(id, statementText, parent) {
     super(id);
+    this.dtoName = RTELogicControlBlock.dtoName;
     this.type = 'logic-control-block';
     this.children = [];
     this.statementText = '';
@@ -71,3 +72,4 @@ export class RTELogicControlBlock extends RTEBlock {
     };
   }
 }
+RTELogicControlBlock.dtoName = 'RTELogicControlBlock';

package/dist/collection/components/vega-rich-text-editor/extensions/functions/dto/logic-control-node.js

@@ -6,6 +6,7 @@ import stateEntityRenderingRegistry from '../../../slimmers/controllers/state-en
 export class RTELogicControlNode extends RTENode {
   constructor(id, text, parent) {
     super(id);
+    this.dtoName = RTELogicControlNode.dtoName;
     this.type = 'logic-control-node';
     this.text = '';
     this.text = text;
@@ -67,3 +68,4 @@ export class RTELogicControlNode extends RTENode {
     return false;
   }
 }
+RTELogicControlNode.dtoName = 'RTELogicControlNode';

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

@@ -27,7 +27,6 @@ const convertFunctionBlockStrategy = new DivToFunctionBlockStrategy();
 export class VegaRTEFunctionExtension extends VegaRTEExtension {
   constructor() {
     super();
-    this.toolbarButtonRenderer = new FunctionToolbarButtonRenderer();
     this.registerBlockBasicStrategies(RTELogicControlBlock.name);
     this.registerBlockBasicStrategies(RTEFunctionBlock.name);
     this.preventFunctionBlockDefaultInsertNewParagraph();
@@ -35,11 +34,14 @@ export class VegaRTEFunctionExtension extends VegaRTEExtension {
     this.registerRenderer('logic-control-block', new RTELogicControlBlockRenderer());
     this.registerNode('function-block', RTEFunctionBlock);
     this.registerRenderer('function-block', new RTEFunctionBlockRenderer());
-    this.registerToolbarButtonRenderer('functions', this.toolbarButtonRenderer);
     this.registerElementToBlockDTOClassStrategy(convertLogicControlBlockStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionContentStrategy);
     this.registerElementToBlockDTOClassStrategy(convertFunctionBlockStrategy);
   }
+  /** @inheritDoc */
+  prepareBeforeLoad(host) {
+    this.registerToolbarButtonRenderer('functions', new FunctionToolbarButtonRenderer(), host);
+  }
   /**
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/action-handler-strategies/block-update-line-height-strategy.js

@@ -0,0 +1,18 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Update the block line height strategy.
+ *
+ * Registered for RTETextBlock and RTEListItemBlock, so the
+ * target type is widened to the common RTEBlock base.
+ */
+export class BlockUpdateLineHeightStrategy extends ActionHandleStrategy {
+  /**
+   * Updating the line height of a block requires cascading updates to the custom style.
+   *
+   * @param {LineHeightAnnotationAction} _action - The line height annotation action.
+   * @param {RTEBlock} target - The current block.
+   */
+  handleAction(_action, target) {
+    this.updateCustomStyleAnnotation(target, ['lineHeight']);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/actions/line-height-annotation-action.js

@@ -0,0 +1,20 @@
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { LineHeightAnnotation } from '../annotations/line-height-annotation';
+/**
+ * Action to update block line height annotation.
+ */
+export class LineHeightAnnotationAction extends AnnotationAction {
+  constructor(lineHeight) {
+    super();
+    this.isFlushable = true;
+    this.lineHeight = lineHeight;
+  }
+  /**
+   * Converts the action to an annotation.
+   *
+   * @returns {LineHeightAnnotation} The annotation.
+   */
+  toAnnotation() {
+    return new LineHeightAnnotation(this.lineHeight);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/annotations/line-height-annotation.js

@@ -0,0 +1,61 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+export var RTELineHeightExtensionAnnotationTypeEnum;
+(function (RTELineHeightExtensionAnnotationTypeEnum) {
+  RTELineHeightExtensionAnnotationTypeEnum["LINE_HEIGHT"] = "LINE_HEIGHT";
+})(RTELineHeightExtensionAnnotationTypeEnum || (RTELineHeightExtensionAnnotationTypeEnum = {}));
+/**
+ * Annotation to set block line height.
+ */
+export class LineHeightAnnotation extends BlockAnnotation {
+  constructor(lineHeight) {
+    super();
+    this.type = RTELineHeightExtensionAnnotationTypeEnum.LINE_HEIGHT;
+    this.lineHeight = lineHeight;
+  }
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @param {string} lineHeight - Line height value.
+   * @returns {[RTELineHeightExtensionAnnotationTypeEnum.LINE_HEIGHT, LineHeightAnnotation]} Map item for the annotation.
+   */
+  static from(lineHeight) {
+    return [RTELineHeightExtensionAnnotationTypeEnum.LINE_HEIGHT, new LineHeightAnnotation(lineHeight)];
+  }
+  /**
+   * Get the default standalone styles for a given line height value.
+   *
+   * @param {string} lineHeight - The line height value.
+   * @returns {AnnotationStyle} The default standalone styles.
+   */
+  static getDefaultStyles(lineHeight) {
+    return { lineHeight };
+  }
+  /**
+   * Generate the JSON item of the annotation.
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation.
+   */
+  toJSON() {
+    return {
+      lineHeight: this.lineHeight,
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass() {
+    return null;
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new LineHeightAnnotation(this.lineHeight);
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle() {
+    return LineHeightAnnotation.getDefaultStyles(this.lineHeight);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/assets/line-height.js

@@ -0,0 +1,3 @@
+export default {
+  icon: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 6.3.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><path fill="currentColor"  d="M113.8 39.9c-4.6-5.1-11-7.9-17.8-7.9s-13.3 2.9-17.8 7.9l-72 80c-8.9 9.9-8.1 25 1.8 33.9s25 8.1 33.9-1.8L72 118.5V393.5L41.8 359.9c-8.9-9.9-24-10.7-33.9-1.8s-10.7 24-1.8 33.9l72 80c4.6 5.1 11 7.9 17.8 7.9s13.3-2.9 17.8-7.9l72-80c8.9-9.9 8.1-25-1.8-33.9s-25-8.1-33.9 1.8L120 393.5V118.5l30.2 33.5c8.9 9.9 24 10.7 33.9 1.8s10.7-24 1.8-33.9l-72-80zM248 72c-13.3 0-24 10.7-24 24s10.7 24 24 24H552c13.3 0 24-10.7 24-24s-10.7-24-24-24H248zm0 160c-13.3 0-24 10.7-24 24s10.7 24 24 24H552c13.3 0 24-10.7 24-24s-10.7-24-24-24H248zM224 416c0 13.3 10.7 24 24 24H552c13.3 0 24-10.7 24-24s-10.7-24-24-24H248c-13.3 0-24 10.7-24 24z"/></svg>`,
+};

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/constants.js

@@ -0,0 +1,11 @@
+/**
+ * Default line height options used by the line-height extension when no
+ * custom options are provided.
+ */
+export const VegaRTEDefaultLineHeightOptions = [
+  { title: '0.5', value: '0.5' },
+  { title: '1', value: '1' },
+  { title: '1.5', value: '1.5' },
+  { title: '2', value: '2' },
+  { title: '2.5', value: '2.5' },
+];

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/element-to-dto-strategies/line-height-annotation-handler.js

@@ -0,0 +1,41 @@
+import { AnnotationGeneratorStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/annotation-generator-strategy.abstract';
+import { RTETextBlock } from '../../../dto/blocks/text-block';
+import { RTEListItemBlock } from '../../../dto/blocks/list-item-block';
+import { VegaRTEDefaultLineHeightOptions } from '../constants';
+const LINE_HEIGHT_AWARE_BLOCK_NAMES = new Set([
+  RTETextBlock.name,
+  RTEListItemBlock.name,
+]);
+/** Handle line height annotation. */
+export class LineHeightAnnotationHandler extends AnnotationGeneratorStrategyAbstract {
+  constructor(options = VegaRTEDefaultLineHeightOptions) {
+    super();
+    this.allowedLineHeights = new Set(options.map((option) => option.value));
+  }
+  /**
+   * Can be handled.
+   *
+   * @param {RTEDtoClassPrototype} targetDto - Target DTO.
+   * @returns {boolean} Whether the target DTO supports line-height annotations.
+   */
+  canHandle(targetDto) {
+    return LINE_HEIGHT_AWARE_BLOCK_NAMES.has(targetDto.name);
+  }
+  /**
+   * Extract inline `line-height` as a semantic `lineHeight` annotation.
+   *
+   * @param {HTMLElement} [element] - Current element.
+   * @returns {VegaRTEBlockAnnotations} `{ lineHeight }` when present, otherwise `{}`.
+   */
+  handle(element) {
+    var _a, _b;
+    const lineHeight = (_b = (_a = element === null || element === void 0 ? void 0 : element.style.lineHeight) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : '';
+    if (!lineHeight) {
+      return {};
+    }
+    if (!this.allowedLineHeights.has(lineHeight)) {
+      return {};
+    }
+    return { lineHeight };
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/element-to-dto-strategies/line-height-filter-styles-strategy.js

@@ -0,0 +1,41 @@
+import { RTEFilterStylesStrategy, } from '../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+/**
+ * Removes a redundant inline `customStyle.lineHeight` when it duplicates the
+ * semantic `lineHeight` annotation during HTML-to-DTO conversion.
+ *
+ * Note: moving out-of-list line-height values from the semantic annotation to
+ * `customStyle.lineHeight` is handled by the per-host interceptor in
+ * `line-height-host-interceptor.ts`, not here.
+ */
+export class LineHeightFilterStylesStrategy extends RTEFilterStylesStrategy {
+  constructor() {
+    super(...arguments);
+    this.stylesToBeFiltered = {};
+  }
+  /**
+   * Always run this strategy, even when autoMatchFormat is disabled.
+   *
+   * @returns {boolean} Always true.
+   */
+  get alwaysFilter() {
+    return true;
+  }
+  /**
+   * Drop `customStyle.lineHeight` when it duplicates the semantic `lineHeight`.
+   *
+   * @param {VegaRTEAnnotations} annotations - The annotations to filter.
+   * @returns {VegaRTEAnnotations} The same annotations reference.
+   */
+  filterAnnotations(annotations) {
+    const blockAnnotations = annotations;
+    const lineHeight = blockAnnotations.lineHeight;
+    const customStyle = blockAnnotations.customStyle;
+    if (lineHeight && customStyle && customStyle.lineHeight === lineHeight) {
+      delete customStyle.lineHeight;
+    }
+    if (customStyle && Object.keys(customStyle).length === 0) {
+      delete blockAnnotations.customStyle;
+    }
+    return annotations;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/line-height/element-to-dto-strategies/line-height-from-json-handler.js

@@ -0,0 +1,65 @@
+import { VegaRTEExtension } from '../../extension.abstract';
+import { LineHeightAnnotation, RTELineHeightExtensionAnnotationTypeEnum, } from '../annotations/line-height-annotation';
+import { CustomStyleAnnotation } from '../../../dto/annotations/custom-style-annotation';
+import { CommonAnnotationTypeEnum } from '../../../dto/annotations/common-annotation.abstract';
+/**
+ * Per-class set of allowed line-height values, updated as extension instances
+ * are constructed with (possibly custom) options.
+ */
+const allowedLineHeightsByClass = new WeakMap();
+/**
+ * Tracks which block classes have had their JSON `lineHeight` annotation
+ * handler installed, so we register it exactly once per class.
+ */
+const handlerInstalledClasses = new WeakSet();
+/**
+ * Move an out-of-range `lineHeight` annotation into `customStyle.lineHeight`.
+ *
+ * @param {RTEBlock} block - The block to inspect.
+ * @param {ReadonlySet<string>} allowed - Allowed line-height values.
+ */
+function normalizeLineHeightStyle(block, allowed) {
+  const annotation = block.annotationMap.get(RTELineHeightExtensionAnnotationTypeEnum.LINE_HEIGHT);
+  if (!annotation || allowed.has(annotation.lineHeight)) {
+    return;
+  }
+  const value = annotation.lineHeight;
+  block.annotationMap.delete(RTELineHeightExtensionAnnotationTypeEnum.LINE_HEIGHT);
+  const existing = block.annotationMap.get(CommonAnnotationTypeEnum.CUSTOM_STYLE);
+  if (existing) {
+    existing.customStyle = Object.assign(Object.assign({}, existing.customStyle), { lineHeight: value });
+  }
+  else {
+    block.annotationMap.set(...CustomStyleAnnotation.from({ lineHeight: value }));
+  }
+}
+/**
+ * Install the JSON `lineHeight` annotation handler for a block class.
+ *
+ * @param {LineHeightBlockClass} BlockClass - Target block class.
+ */
+export function attachLineHeightFromJson(BlockClass) {
+  if (handlerInstalledClasses.has(BlockClass)) {
+    return;
+  }
+  handlerInstalledClasses.add(BlockClass);
+  VegaRTEExtension.attachAnnotationFromJson(BlockClass, 'lineHeight', (instance, value) => {
+    if (typeof value !== 'string' || value === '') {
+      return;
+    }
+    instance.annotationMap.set(...LineHeightAnnotation.from(value));
+    const allowed = allowedLineHeightsByClass.get(BlockClass);
+    if (allowed && allowed.size > 0) {
+      normalizeLineHeightStyle(instance, allowed);
+    }
+  });
+}
+/**
+ * Update the set of allowed line-height values for a block class.
+ *
+ * @param {LineHeightBlockClass} BlockClass - Target block class.
+ * @param {VegaRTELineHeightOption[]} options - Allowed line-height options.
+ */
+export function setAllowedLineHeights(BlockClass, options) {
+  allowedLineHeightsByClass.set(BlockClass, new Set(options.map((option) => option.value)));
+}

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

@@ -0,0 +1,44 @@
+import { VegaRTEDefaultLineHeightOptions } from './constants';
+import { VegaRTEExtension } from '../extension.abstract';
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import { RTEListItemBlock } from '../../dto/blocks/list-item-block';
+import { LineHeightAnnotationAction } from './actions/line-height-annotation-action';
+import { BlockUpdateLineHeightStrategy } from './action-handler-strategies/block-update-line-height-strategy';
+import { RTELineHeightToolbarButtonRenderer } from './line-height-toolbar-button-renderer';
+import { LineHeightAnnotationHandler } from './element-to-dto-strategies/line-height-annotation-handler';
+import { LineHeightFilterStylesStrategy } from './element-to-dto-strategies/line-height-filter-styles-strategy';
+import { attachLineHeightFromJson, setAllowedLineHeights, } from './element-to-dto-strategies/line-height-from-json-handler';
+import { RTEFilterStylesStrategyRegistry } from '../../dto/filter-styles-strategies/filter-styles-strategy-registry';
+/**
+ * Rich Text Editor extension that adds configurable line-height support
+ * (toolbar control, annotations, content transforms, and JSON parsing).
+ */
+export class VegaRTELineHeightExtension extends VegaRTEExtension {
+  constructor(options = VegaRTEDefaultLineHeightOptions) {
+    super();
+    this.options = options;
+    this.toolbarButtonRenderer = null;
+    this.registerAnnotationHandler(new LineHeightAnnotationHandler(this.options));
+    [RTETextBlock, RTEListItemBlock].forEach((BlockClass) => {
+      setAllowedLineHeights(BlockClass, this.options);
+    });
+  }
+  /**
+   * Register the per-host toolbar renderer so each editor on the page gets
+   * its own isolated line-height renderer instance.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {HTMLVegaRichTextEditorElement} host - The host element.
+   */
+  prepareBeforeLoad(host) {
+    this.toolbarButtonRenderer = new RTELineHeightToolbarButtonRenderer(this.options);
+    this.registerToolbarButtonRenderer('lineHeight', this.toolbarButtonRenderer, host);
+  }
+}
+(() => {
+  [RTETextBlock, RTEListItemBlock].forEach((BlockClass) => {
+    VegaRTEExtension.registerActionHandleStrategy(BlockClass.name, LineHeightAnnotationAction.name, new BlockUpdateLineHeightStrategy());
+    RTEFilterStylesStrategyRegistry.register(BlockClass.name, new LineHeightFilterStylesStrategy());
+    attachLineHeightFromJson(BlockClass);
+  });
+})();

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

@@ -0,0 +1,131 @@
+import { ActionHandleStrategyRegistry } from '../../dto/action-handle-strategies/action-handle-strategy-registry';
+import { RTEBlock } from '../../dto/blocks/block.abstract';
+import { VegaInternalIconManager } from '../../../../helpers/icon/internal-icon-manager';
+import lineHeight from './assets/line-height';
+import { RTECodeBlock } from '../../dto/blocks/code-block';
+import { RTEImageBlock } from '../../dto/blocks/image-block';
+import { NodeAnnotationTypeEnum } from '../../dto/annotations/node-annotation.abstract';
+import { LineHeightAnnotationAction } from './actions/line-height-annotation-action';
+import { RTELineHeightExtensionAnnotationTypeEnum, } from './annotations/line-height-annotation';
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+import { VegaInternalTranslation } from '../../../../helpers/translation/internal-translation-controller';
+/**
+ * Renderer for the line-height toolbar button in the Vega Rich Text Editor.
+ */
+export class RTELineHeightToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * @inheritDoc
+   */
+  render(createElement, editorContext) {
+    const dropdownItems = this.options.map((item) => {
+      var _a;
+      return ({
+        key: item.value,
+        label: (_a = item.title) !== null && _a !== void 0 ? _a : item.value,
+      });
+    });
+    return this.renderDropdown(createElement, editorContext, {
+      selectType: 'single',
+      selectedSourceKey: this.getSelectedSourceValue(editorContext),
+    }, [
+      this.renderButton(createElement, editorContext, {
+        icon: 'line-height',
+        showArrowIcon: true,
+        tooltip: { text: VegaInternalTranslation.t('Line Height') },
+      }),
+      this.renderDropdownListTemplate(createElement, dropdownItems),
+    ]);
+  }
+  /**
+   * @inheritDoc
+   */
+  isSelected() {
+    return false;
+  }
+  /**
+   * @inheritDoc
+   */
+  isDisabled(editorContext) {
+    var _a;
+    if (editorContext.host.disabled) {
+      return true;
+    }
+    const extensionContext = this.getExtensionContext(editorContext.host);
+    const selectedNodes = (_a = extensionContext === null || extensionContext === void 0 ? void 0 : extensionContext.getSelectedNodes()) !== null && _a !== void 0 ? _a : [];
+    if (selectedNodes.some((node) => {
+      var _a;
+      return ((_a = node.getAnnotationByType(NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
+        node.parent instanceof RTECodeBlock;
+    })) {
+      return true;
+    }
+    const selectedBlocks = this.getSelectedBlocks(editorContext);
+    return selectedBlocks.some((block) => block instanceof RTECodeBlock ||
+      block instanceof RTEImageBlock ||
+      !ActionHandleStrategyRegistry.canHandle(LineHeightAnnotationAction.name, block));
+  }
+  /**
+   * @inheritDoc
+   */
+  handleDropdownClick(itemValue, editorContext) {
+    const selectedLineHeight = itemValue;
+    const selectedBlocks = this.getSelectedBlocks(editorContext);
+    selectedBlocks.forEach((block) => {
+      block.apply(new LineHeightAnnotationAction(selectedLineHeight));
+    });
+  }
+  /**
+   * Handle direct toolbar button click.
+   */
+  handleButtonClick() {
+    // No direct click action; selection happens in dropdown options.
+  }
+  /**
+   * Get the selected line-height key for dropdown selection state.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - Current toolbar context.
+   * @returns {string} Selected line-height key or empty string for mixed/none.
+   */
+  getSelectedSourceValue(editorContext) {
+    const selectedBlocks = this.getSelectedBlocks(editorContext);
+    if (selectedBlocks.length === 0) {
+      return '';
+    }
+    const firstAnnotation = selectedBlocks[0].getAnnotationByType(RTELineHeightExtensionAnnotationTypeEnum.LINE_HEIGHT);
+    const isSameLineHeight = selectedBlocks.every((block) => {
+      const annotation = block.getAnnotationByType(RTELineHeightExtensionAnnotationTypeEnum.LINE_HEIGHT);
+      return (annotation === null || annotation === void 0 ? void 0 : annotation.lineHeight) === (firstAnnotation === null || firstAnnotation === void 0 ? void 0 : firstAnnotation.lineHeight);
+    });
+    return isSameLineHeight && firstAnnotation ? firstAnnotation.lineHeight : '';
+  }
+  /**
+   * Resolve selected blocks from selected nodes with range fallback.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - Current toolbar context.
+   * @returns {RTEBlock[]} Selected blocks.
+   */
+  getSelectedBlocks(editorContext) {
+    var _a, _b;
+    const extensionContext = this.getExtensionContext(editorContext.host);
+    const selectedNodes = (_a = extensionContext === null || extensionContext === void 0 ? void 0 : extensionContext.getSelectedNodes()) !== null && _a !== void 0 ? _a : [];
+    const selectedBlocks = [];
+    selectedNodes.forEach((node) => {
+      if (node.parent instanceof RTEBlock && !selectedBlocks.includes(node.parent)) {
+        selectedBlocks.push(node.parent);
+      }
+    });
+    if (selectedBlocks.length === 0 && ((_b = editorContext.rteRange.startNode) === null || _b === void 0 ? void 0 : _b.parent) instanceof RTEBlock) {
+      selectedBlocks.push(editorContext.rteRange.startNode.parent);
+    }
+    return selectedBlocks;
+  }
+}
+(() => {
+  VegaInternalIconManager.register({
+    'line-height': lineHeight,
+  });
+})();

package/dist/collection/components/vega-rich-text-editor/extensions/special-characters/constants/arrow-characters.js

@@ -0,0 +1,24 @@
+export const ARROW_CHARACTERS = [
+  { character: '←', title: 'leftwards simple arrow' },
+  { character: '→', title: 'rightwards simple arrow' },
+  { character: '↑', title: 'upwards simple arrow' },
+  { character: '↓', title: 'downwards simple arrow' },
+  { character: '⇐', title: 'leftwards double arrow' },
+  { character: '⇒', title: 'rightwards double arrow' },
+  { character: '⇑', title: 'upwards double arrow' },
+  { character: '⇓', title: 'downwards double arrow' },
+  { character: '⇠', title: 'leftwards dashed arrow' },
+  { character: '⇢', title: 'rightwards dashed arrow' },
+  { character: '⇡', title: 'upwards dashed arrow' },
+  { character: '⇣', title: 'downwards dashed arrow' },
+  { character: '⇤', title: 'leftwards arrow to bar' },
+  { character: '⇥', title: 'rightwards arrow to bar' },
+  { character: '⤒', title: 'upwards arrow to bar' },
+  { character: '⤓', title: 'downwards arrow to bar' },
+  { character: '↨', title: 'up down arrow with base' },
+  { character: '🔙', title: 'back with leftwards arrow above' },
+  { character: '🔚', title: 'end with leftwards arrow above' },
+  { character: '🔛', title: 'on with exclamation mark with left right arrow above' },
+  { character: '🔜', title: 'soon with rightwards arrow above' },
+  { character: '🔝', title: 'top with upwards arrow above' },
+];

package/dist/collection/components/vega-rich-text-editor/extensions/special-characters/constants/currency-characters.js

@@ -0,0 +1,38 @@
+export const CURRENCY_CHARACTERS = [
+  { character: '$', title: 'Dollar sign' },
+  { character: '€', title: 'Euro sign' },
+  { character: '¥', title: 'Yen sign' },
+  { character: '£', title: 'Pound sign' },
+  { character: '¢', title: 'Cent sign' },
+  { character: '₠', title: 'Euro-currency sign' },
+  { character: '₡', title: 'Colon sign' },
+  { character: '₢', title: 'Cruzeiro sign' },
+  { character: '₣', title: 'French franc sign' },
+  { character: '₤', title: 'Lira sign' },
+  { character: '¤', title: 'Currency sign' },
+  { character: '₿', title: 'Bitcoin sign' },
+  { character: '₥', title: 'Mill sign' },
+  { character: '₦', title: 'Naira sign' },
+  { character: '₧', title: 'Peseta sign' },
+  { character: '₨', title: 'Rupee sign' },
+  { character: '₩', title: 'Won sign' },
+  { character: '₪', title: 'New sheqel sign' },
+  { character: '₫', title: 'Dong sign' },
+  { character: '₭', title: 'Kip sign' },
+  { character: '₮', title: 'Tugrik sign' },
+  { character: '₯', title: 'Drachma sign' },
+  { character: '₰', title: 'German penny sign' },
+  { character: '₱', title: 'Peso sign' },
+  { character: '₲', title: 'Guarani sign' },
+  { character: '₳', title: 'Austral sign' },
+  { character: '₴', title: 'Hryvnia sign' },
+  { character: '₵', title: 'Cedi sign' },
+  { character: '₶', title: 'Livre tournois sign' },
+  { character: '₷', title: 'Spesmilo sign' },
+  { character: '₸', title: 'Tenge sign' },
+  { character: '₹', title: 'Indian rupee sign' },
+  { character: '₺', title: 'Turkish lira sign' },
+  { character: '₻', title: 'Nordic mark sign' },
+  { character: '₼', title: 'Manat sign' },
+  { character: '₽', title: 'Ruble sign' },
+];