@globalpayments/vega 2.57.1 → 2.59.0

package/dist/collection/components/vega-rich-text-editor/dto/actions/update-cursor-position-action.js

@@ -0,0 +1,20 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Update the cursor position in the editor.
+ *
+ * @example richEditorRef.value.apply(new UpdateCursorPositionAction(nextFocusNode, [offset]))
+ */
+export class UpdateCursorPositionAction extends ModifyContentAction {
+  /**
+   * Set the cursor position at end of the current node.
+   *
+   * @param {RTENode} nextFocusNode - The rich text editor needs focus node.
+   * @param {number} offset - The cursor offset position.
+   */
+  constructor(nextFocusNode, offset) {
+    super();
+    this.type = ModifyContentActionType.UPDATE_CURSOR_POSITION;
+    this.nextFocusNode = nextFocusNode;
+    this.offset = offset;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/block-annotation.abstract.js

@@ -4,6 +4,8 @@ export var BlockAnnotationTypeEnum;
   BlockAnnotationTypeEnum["ALIGNMENT"] = "ALIGNMENT";
   BlockAnnotationTypeEnum["TEXT_STYLE"] = "TEXT_STYLE";
   BlockAnnotationTypeEnum["INDENT"] = "INDENT";
+  BlockAnnotationTypeEnum["LIST"] = "LIST";
+  BlockAnnotationTypeEnum["INTERNAL_WRAPPER"] = "INTERNAL_WRAPPER";
 })(BlockAnnotationTypeEnum || (BlockAnnotationTypeEnum = {}));
 /**
  * BlockAnnotation is an abstract class that represents a block annotation.

package/dist/collection/components/vega-rich-text-editor/dto/annotations/bold-annotation.js

@@ -34,11 +34,19 @@ export class BoldAnnotation extends NodeAnnotation {
     return new BoldAnnotation(this.bold);
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return this.bold ? 'v-rte--bold' : null;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
-    return this.bold ? { 'font-weight': '700' } : null;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return this.bold ? { fontWeight: '700' } : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/clear-formatting-annotation.js

@@ -1,4 +1,5 @@
 import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
+import { CommonAnnotationTypeEnum } from './common-annotation.abstract';
 import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
 /**
  * Annotation to host which annotations will be clear formatting
@@ -14,6 +15,7 @@ export class ClearFormattingAnnotation extends Annotation {
       NodeAnnotationTypeEnum.STRIKETHROUGH,
       NodeAnnotationTypeEnum.TEXT_COLOR,
       NodeAnnotationTypeEnum.CODE,
+      CommonAnnotationTypeEnum.CUSTOM_STYLE,
     ];
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/code-annotation.js

@@ -3,19 +3,21 @@ import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstra
  * Annotation to make text code
  */
 export class CodeAnnotation extends NodeAnnotation {
-  constructor(code) {
+  constructor(code, useInternalStyle = true) {
     super();
     this.type = NodeAnnotationTypeEnum.CODE;
     this.code = code;
+    this.useInternalStyle = useInternalStyle;
   }
   /**
    * Generate the map item for the annotation
    *
    * @param {boolean} code - Bold annotation
+   * @param {boolean} useInternalStyle - Whether to use default style for the link
    * @returns {[NodeAnnotationTypeEnum.CODE, CodeAnnotation]} Map item for the annotation
    */
-  static from(code) {
-    return [NodeAnnotationTypeEnum.CODE, new CodeAnnotation(code)];
+  static from(code, useInternalStyle) {
+    return [NodeAnnotationTypeEnum.CODE, new CodeAnnotation(code, useInternalStyle)];
   }
   /**
    * Generate the JSON representation of the annotation
@@ -31,22 +33,27 @@ export class CodeAnnotation extends NodeAnnotation {
    * @inheritDoc
    */
   clone() {
-    return new CodeAnnotation(this.code);
+    return new CodeAnnotation(this.code, this.useInternalStyle);
   }
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
-  renderClass() {
-    return this.code ? 'v-rte--code' : null;
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return this.code && this.useInternalStyle ? 'v-rte--code' : null;
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
+   * @inheritDoc
    */
-  render() {
-    return null;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return this.code && this.useInternalStyle
+      ? {
+        fontFamily: 'Roboto Mono',
+        whiteSpace: 'pre-wrap',
+      }
+      : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/common-annotation.abstract.js

@@ -0,0 +1,12 @@
+import { Annotation } from './annotation.abstract';
+export var CommonAnnotationTypeEnum;
+(function (CommonAnnotationTypeEnum) {
+  CommonAnnotationTypeEnum["CUSTOM_ATTRIBUTE"] = "CUSTOM_ATTRIBUTE";
+  CommonAnnotationTypeEnum["CUSTOM_CLASS"] = "CUSTOM_CLASS";
+  CommonAnnotationTypeEnum["CUSTOM_STYLE"] = "CUSTOM_STYLE";
+})(CommonAnnotationTypeEnum || (CommonAnnotationTypeEnum = {}));
+/**
+ * CommonAnnotation is an abstract class that represents common annotation for block and node.
+ */
+export class CommonAnnotation extends Annotation {
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/custom-attribute-annotation.js

@@ -0,0 +1,80 @@
+import { isNonNullable } from '../../../../types/type-guard';
+import { CommonAnnotation, CommonAnnotationTypeEnum } from './common-annotation.abstract';
+/**
+ * Annotation to add custom attributes of element
+ */
+export class CustomAttributeAnnotation extends CommonAnnotation {
+  constructor(customAttribute) {
+    super();
+    this.type = CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE;
+    this.BOOLEAN_ATTRS = new Set([
+      'controls',
+      'disabled',
+      'checked',
+      'readonly',
+      'multiple',
+      'required',
+      'autoplay',
+      'muted',
+    ]);
+    this.customAttribute = customAttribute;
+  }
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {Record<string, string>} customizeAttribute - custom attribute annotation
+   * @returns {[CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE, CustomAttributeAnnotation]} Map item for the annotation
+   */
+  static from(customizeAttribute) {
+    return [CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE, new CustomAttributeAnnotation(customizeAttribute)];
+  }
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON() {
+    return {
+      customAttribute: this.customAttribute,
+    };
+  }
+  /**
+   * Create a new custom attribute annotation
+   *
+   * @returns {CustomAttributeAnnotation} - Custom attribute annotation
+   */
+  clone() {
+    return new CustomAttributeAnnotation(this.customAttribute);
+  }
+  /**
+   * Generate the custom attribute of current element, excluding 'style' and 'class'
+   *
+   * @param {string[]} filterAttr - should filter these existed attrs
+   * @returns {string[]} - Custom attributes
+   */
+  toString(filterAttr = []) {
+    const filterAttrKeys = filterAttr.map((attr) => attr.split('=')[0]);
+    return Object.keys(this.customAttribute)
+      .map((key) => {
+      return !filterAttrKeys.includes(key) ? `${key}="${this.customAttribute[key]}"` : null;
+    })
+      .filter(isNonNullable);
+  }
+  /**
+   * Generate the custom attribute for the annotation
+   *
+   * @param {RTERenderCustomAttributes} options - should filter these certain attrs
+   * @returns {Record<string, string>} custom attribute
+   */
+  render(options = {}) {
+    var _a;
+    const customAttribute = Object.assign({}, this.customAttribute);
+    (_a = options.filterAttributes) === null || _a === void 0 ? void 0 : _a.forEach((attr) => delete customAttribute[attr]);
+    Object.keys(customAttribute).forEach((key) => {
+      if (this.BOOLEAN_ATTRS.has(key) && customAttribute[key] === '') {
+        customAttribute[key] = 'true';
+      }
+    });
+    return customAttribute;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/custom-class-annotation.js

@@ -0,0 +1,54 @@
+import { CommonAnnotation, CommonAnnotationTypeEnum } from './common-annotation.abstract';
+/**
+ * Annotation to add custom class of element
+ */
+export class CustomClassAnnotation extends CommonAnnotation {
+  constructor(customClass) {
+    super();
+    this.type = CommonAnnotationTypeEnum.CUSTOM_CLASS;
+    this.customClass = customClass;
+  }
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {string[]} customClass - custom class annotation
+   * @returns {[CommonAnnotationTypeEnum.CUSTOM_CLASS, CustomClassAnnotation]} Map item for the annotation
+   */
+  static from(customClass) {
+    return [CommonAnnotationTypeEnum.CUSTOM_CLASS, new CustomClassAnnotation(customClass)];
+  }
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON() {
+    return {
+      customClass: this.customClass,
+    };
+  }
+  /**
+   * Create a new custom class annotation
+   *
+   * @returns {CustomClassAnnotation} - Custom class annotation
+   */
+  clone() {
+    return new CustomClassAnnotation(this.customClass);
+  }
+  /**
+   * Generate the custom class of current element
+   *
+   * @returns {string} - Custom class
+   */
+  toString() {
+    return `class="${this.customClass.join(' ')}"`;
+  }
+  /**
+   * Generate the custom attribute for the annotation
+   *
+   * @returns {string[]} custom classes
+   */
+  renderClass() {
+    return this.customClass;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/custom-style-annotation.js

@@ -0,0 +1,67 @@
+import { CommonAnnotation, CommonAnnotationTypeEnum } from './common-annotation.abstract';
+/**
+ * Annotation to add custom attributes of element
+ */
+export class CustomStyleAnnotation extends CommonAnnotation {
+  constructor(customStyle) {
+    super();
+    this.type = CommonAnnotationTypeEnum.CUSTOM_STYLE;
+    this.customStyle = customStyle;
+  }
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {AnnotationStyle} customStyle - custom attribute annotation
+   * @returns {[CommonAnnotationTypeEnum.CUSTOM_STYLE, CustomStyleAnnotation]} Map item for the annotation
+   */
+  static from(customStyle) {
+    return [CommonAnnotationTypeEnum.CUSTOM_STYLE, new CustomStyleAnnotation(customStyle)];
+  }
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON() {
+    return {
+      customStyle: this.customStyle,
+    };
+  }
+  /**
+   * Create a new custom attribute annotation
+   *
+   * @returns {CustomStyleAnnotation} - Custom attribute annotation
+   */
+  clone() {
+    return new CustomStyleAnnotation(this.customStyle);
+  }
+  /**
+   * Generate the custom attribute for the annotation
+   *
+   * @returns {AnnotationStyle} custom attribute
+   */
+  renderStyle() {
+    return this.customStyle;
+  }
+  /**
+   * Remove the style
+   *
+   * @param {string[]} styleKeys - custom attribute annotation
+   * @returns {AnnotationStyle} Map item for the annotation
+   */
+  removeStyles(styleKeys) {
+    const customStyle = Object.assign({}, this.customStyle);
+    styleKeys.forEach((item) => delete customStyle[item]);
+    return customStyle;
+  }
+  /**
+   * Generate the custom style string for the annotation
+   *
+   * @returns {string} custom style string
+   */
+  toString() {
+    return `style="${Object.entries(this.customStyle)
+      .map(([key, value]) => `${key}: ${value};`)
+      .join(' ')}"`;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/horizontal-alignment-annotation.js

@@ -28,12 +28,20 @@ export class HorizontalAlignmentAnnotation extends BlockAnnotation {
     };
   }
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {string} - Annotation class
+   * @inheritDoc
    */
-  renderClass() {
-    return `v-rte--horizontal-alignment-${this.textAlign}`;
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    switch (this.textAlign) {
+      case 'right':
+      case 'center':
+      case 'justify':
+        return `v-rte--horizontal-alignment-${this.textAlign}`;
+      case 'left':
+      default:
+        return `v-rte--horizontal-alignment-left`;
+    }
   }
   /**
    * @inheritDoc
@@ -42,11 +50,19 @@ export class HorizontalAlignmentAnnotation extends BlockAnnotation {
     return new HorizontalAlignmentAnnotation(this.textAlign);
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render() {
-    return null;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    switch (this.textAlign) {
+      case 'right':
+      case 'center':
+      case 'justify':
+        return { textAlign: this.textAlign };
+      case 'left':
+      default:
+        return { textAlign: 'left' };
+    }
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/image-annotation.js

@@ -4,7 +4,7 @@ import { isNonNullable } from '../../../../types/type-guard';
  * Annotation for image
  */
 export class ImageAnnotation extends NodeAnnotation {
-  constructor(size = 'md', alt) {
+  constructor(size, alt) {
     super();
     this.type = NodeAnnotationTypeEnum.IMAGE;
     this.size = size;
@@ -42,20 +42,29 @@ export class ImageAnnotation extends NodeAnnotation {
     return new ImageAnnotation(this.size, this.alt);
   }
   /**
-   * Generate the style for the image
-   *
-   * @returns {Nullable<AnnotationStyle>} image style
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return this.size ? `v-rte--image-size-${this.size}` : null;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    const baseStyle = { verticalAlign: 'bottom' };
     switch (this.size) {
       case 'sm': {
-        return { width: '25%' };
+        return Object.assign(Object.assign({}, baseStyle), { width: '25%' });
       }
       case 'md': {
-        return { width: '50%' };
+        return Object.assign(Object.assign({}, baseStyle), { width: '50%' });
       }
       case 'lg': {
-        return { width: '100%' };
+        return Object.assign(Object.assign({}, baseStyle), { width: '100%' });
       }
     }
   }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/indent-annotation.js

@@ -31,12 +31,18 @@ export class IndentAnnotation extends BlockAnnotation {
   clone() {
     return new IndentAnnotation(this.indent);
   }
+  /**
+   * @inheritDoc
+   */
+  renderClass() {
+    return null;
+  }
   /**
    * Generate the style for the annotation
    *
    * @returns {Nullable<AnnotationStyle>} - Annotation style
    */
-  render() {
-    return this.indent > 0 ? { 'margin-left': `${this.indent * 16}px` } : null;
+  renderStyle() {
+    return this.indent > 0 ? { marginLeft: `${this.indent * 16}px` } : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/inline-html-annotation.js

@@ -0,0 +1,68 @@
+import { Annotation } from './annotation.abstract';
+import { CustomAttributeAnnotation } from './custom-attribute-annotation';
+import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
+import { CustomClassAnnotation } from './custom-class-annotation';
+import { CustomStyleAnnotation } from './custom-style-annotation';
+import { cleanObject } from '../../../../utils/object';
+/**
+ * Inline HTML annotation
+ */
+export class InlineHtmlAnnotation extends Annotation {
+  constructor(htmlTag) {
+    super();
+    this.type = NodeAnnotationTypeEnum.INLINE_HTML;
+    this.htmlTag = htmlTag;
+  }
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {VegaInlineHtmlSchema} inlineHtml - Inline HTML node
+   * @returns {[NodeAnnotationTypeEnum.INLINE_HTML, InlineHtmlAnnotation]} Map item for the annotation
+   */
+  static from(inlineHtml) {
+    const { htmlTag, child, customStyle, customClass, customAttribute } = inlineHtml;
+    const inlineHtmlAnnotation = new InlineHtmlAnnotation(htmlTag);
+    inlineHtmlAnnotation.child = child ? InlineHtmlAnnotation.from(child)[1] : undefined;
+    inlineHtmlAnnotation.customAttribute = customAttribute
+      ? CustomAttributeAnnotation.from(customAttribute)[1]
+      : undefined;
+    inlineHtmlAnnotation.customClass = customClass
+      ? CustomClassAnnotation.from(customClass)[1]
+      : undefined;
+    inlineHtmlAnnotation.customStyle = customStyle
+      ? CustomStyleAnnotation.from(customStyle)[1]
+      : undefined;
+    return [NodeAnnotationTypeEnum.INLINE_HTML, inlineHtmlAnnotation];
+  }
+  /**
+   * Create a new inline HTML annotation
+   *
+   * @returns {InlineHtmlAnnotation} - Inline HTML annotation
+   */
+  clone() {
+    var _a, _b, _c, _d;
+    const inlineHtmlAnnotation = new InlineHtmlAnnotation(this.htmlTag);
+    inlineHtmlAnnotation.child = (_a = this.child) === null || _a === void 0 ? void 0 : _a.clone();
+    inlineHtmlAnnotation.customAttribute = (_b = this.customAttribute) === null || _b === void 0 ? void 0 : _b.clone();
+    inlineHtmlAnnotation.customClass = (_c = this.customClass) === null || _c === void 0 ? void 0 : _c.clone();
+    inlineHtmlAnnotation.customStyle = (_d = this.customStyle) === null || _d === void 0 ? void 0 : _d.clone();
+    return inlineHtmlAnnotation;
+  }
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON() {
+    var _a, _b, _c, _d;
+    return {
+      inlineHtml: cleanObject({
+        htmlTag: this.htmlTag,
+        child: (_a = this.child) === null || _a === void 0 ? void 0 : _a.toJSON().inlineHtml,
+        customAttribute: (_b = this.customAttribute) === null || _b === void 0 ? void 0 : _b.toJSON().customAttribute,
+        customClass: (_c = this.customClass) === null || _c === void 0 ? void 0 : _c.toJSON().customClass,
+        customStyle: (_d = this.customStyle) === null || _d === void 0 ? void 0 : _d.toJSON().customStyle,
+      }),
+    };
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/internal-wrapper-annotation.js

@@ -0,0 +1,41 @@
+import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
+/**
+ * Internal wrapper annotation for block node.
+ */
+export class InternalWrapperAnnotation extends BlockAnnotation {
+  constructor(internalWrapper) {
+    super();
+    this.type = BlockAnnotationTypeEnum.INTERNAL_WRAPPER;
+    this.internalWrapper = internalWrapper;
+  }
+  /**
+   * @inheritDoc
+   */
+  static from(internalWrapper) {
+    return [BlockAnnotationTypeEnum.INTERNAL_WRAPPER, new InternalWrapperAnnotation(internalWrapper)];
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    return new InternalWrapperAnnotation(this.internalWrapper);
+  }
+  /**
+   * @inheritDoc
+   */
+  renderClass() {
+    return undefined;
+  }
+  /**
+   * @inheritDoc
+   */
+  renderStyle() {
+    return undefined;
+  }
+  /**
+   * @inheritDoc
+   */
+  toJSON() {
+    return this.internalWrapper ? { internalWrapper: this.internalWrapper } : undefined;
+  }
+}

package/dist/collection/components/vega-rich-text-editor/dto/annotations/italic-annotation.js

@@ -34,11 +34,19 @@ export class ItalicAnnotation extends NodeAnnotation {
     return new ItalicAnnotation(this.italic);
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Italic style
+   * @inheritDoc
+   */
+  renderClass(options) {
+    if (options === null || options === void 0 ? void 0 : options.standalone)
+      return null;
+    return this.italic ? 'v-rte--italic' : null;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
-    return this.italic ? { 'font-style': 'italic' } : null;
+  renderStyle(options) {
+    if (!(options === null || options === void 0 ? void 0 : options.standalone))
+      return null;
+    return this.italic ? { fontStyle: 'italic' } : null;
   }
 }

package/dist/collection/components/vega-rich-text-editor/dto/annotations/link-annotation.js

@@ -3,22 +3,21 @@ import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstra
  * Annotation to make text a link
  */
 export class LinkAnnotation extends NodeAnnotation {
-  constructor(link) {
+  constructor(link, useInternalStyle = true) {
     super();
     this.type = NodeAnnotationTypeEnum.LINK;
     this.link = link;
+    this.useInternalStyle = useInternalStyle;
   }
   /**
    * Generate the map item for the annotation
    *
    * @param {VegaRTELink} link - Bold annotation
+   * @param {boolean} useInternalStyle - Whether to use default style for the link
    * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
    */
-  static from(link) {
-    return [
-      NodeAnnotationTypeEnum.LINK,
-      new LinkAnnotation({ href: link.href, groupKey: link.groupKey }),
-    ];
+  static from(link, useInternalStyle = true) {
+    return [NodeAnnotationTypeEnum.LINK, new LinkAnnotation(link, useInternalStyle)];
   }
   /**
    * Generate the JSON representation of the annotation
@@ -26,7 +25,9 @@ export class LinkAnnotation extends NodeAnnotation {
    * @returns {Record<'link', VegaRTELink>} JSON representation of the annotation
    */
   toJSON() {
-    return { link: { href: this.link.href, groupKey: this.link.groupKey } };
+    return {
+      link: this.link,
+    };
   }
   /**
    * @inheritDoc
@@ -44,11 +45,15 @@ export class LinkAnnotation extends NodeAnnotation {
     return this.link.groupKey === annotation.link.groupKey;
   }
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Link style
+   * @inheritDoc
+   */
+  renderClass() {
+    return null;
+  }
+  /**
+   * @inheritDoc
    */
-  render() {
+  renderStyle() {
     return null;
   }
 }