@globalpayments/vega 2.91.0 → 2.93.0

package/dist/collection/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/replace-controller.js

@@ -0,0 +1,113 @@
+import { FindReplaceControllerAbstract, } from './find-replace-controller.abstract';
+/**
+ * Replace controller — adds mutation capabilities on top of the shared
+ * find state.
+ *
+ * Shares state with {@link FindController} via the injected
+ * {@link FindReplaceControllerContext}, so both controllers always operate
+ * on the same search results and highlight overlays.
+ */
+export class ReplaceController extends FindReplaceControllerAbstract {
+  constructor(context) {
+    super(context);
+    /** The replacement string used by replace() and replaceAll(). Updated via setReplacement(). */
+    this.replacement = '';
+    this.flushFn = null;
+  }
+  /**
+   * Stores the flush callback used to commit content changes to the editor.
+   * Called by the toolbar renderer after obtaining it from the extension context.
+   *
+   * Calling `flushValue` once — even after mutating multiple nodes — creates a
+   * single entry in the editor's undo stack, so the entire replace/replaceAll
+   * operation is undone as one atomic step.
+   *
+   * @param {(value: VegaRTEContent) => void} fn - The flush function.
+   * @returns {void} No return value.
+   */
+  setFlushValue(fn) {
+    this.flushFn = fn;
+  }
+  /**
+   * Stores the replacement text for the next replace() or replaceAll() call.
+   *
+   * @param {string} text - The replacement string.
+   * @returns {void} No return value.
+   */
+  setReplacement(text) {
+    this.replacement = text;
+  }
+  /**
+   * Replaces the current match with the stored replacement text,
+   * advances to the next match, and refreshes highlights.
+   * An empty replacement string deletes the matched text.
+   *
+   * No-op when there is no current match or no host.
+   *
+   * @returns {FindReplaceResult} Updated match position and total.
+   */
+  replace() {
+    const currentMatch = this.context.state.getCurrentMatch();
+    if (currentMatch && this.context.hostRef && this.flushFn) {
+      const previousIndex = this.context.state.getCurrentIndex();
+      this.applyMatchReplacement(currentMatch);
+      this.flushFn(this.context.hostRef.value);
+      this.context.state.clear();
+      this.context.state.search(this.context.hostRef.value, this.context.keyword);
+      // setCurrentIndex clamps to [0, total-1], so passing previousIndex
+      // directly keeps the cursor as close as possible to the replaced position
+      // rather than wrapping around when previousIndex >= total.
+      this.context.state.setCurrentIndex(previousIndex);
+    }
+    return this.applyAndGetResult();
+  }
+  /**
+   * Replaces all matches with the stored replacement text in a single operation
+   * (one flushValue call = one Undo step), then re-runs the search.
+   * An empty replacement string deletes all matched text.
+   *
+   * No-op when there are no matches or no host.
+   *
+   * @returns {FindReplaceResult} Updated match position and total.
+   */
+  replaceAll() {
+    if (this.context.state.getTotal() > 0 && this.flushFn && this.context.hostRef) {
+      const matches = this.context.state.getMatches();
+      // Iterate in reverse so that mutating a later match does not shift the
+      // startOffset/endOffset of earlier matches that have not yet been processed.
+      for (let i = matches.length - 1; i >= 0; i -= 1) {
+        this.applyMatchReplacement(matches[i]);
+      }
+      this.flushFn(this.context.hostRef.value);
+      this.context.state.clear();
+      this.context.state.search(this.context.hostRef.value, this.context.keyword);
+    }
+    return this.applyAndGetResult();
+  }
+  // ─── Private ──────────────────────────────────────────────────────────────────
+  /**
+   * Directly mutates the matched nodes in the live content tree.
+   * `position.node` is already a reference into `this.context.hostRef.value`,
+   * so no cloning or path navigation is needed.
+   *
+   * For multi-node (cross-span) matches the first node receives the replacement
+   * text and every subsequent node has its matched slice deleted.
+   *
+   * This method mutates the content tree in place. The caller is
+   * responsible for calling `state.clear()` afterwards to invalidate the
+   * flat-text cache, which uses reference equality and will not detect the
+   * in-place change automatically.
+   *
+   * @param {FindMatch} match - The match to replace.
+   * @returns {void} No return value.
+   */
+  applyMatchReplacement(match) {
+    match.nodes.forEach((position, index) => {
+      const replacementText = index === 0 ? this.replacement : '';
+      position.node.text =
+        position.node.text.slice(0, position.startOffset) +
+          replacementText +
+          position.node.text.slice(position.endOffset);
+    });
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/find-replace/slimmer/renderers/find-replace-toolbar-button-renderer.js

@@ -0,0 +1,194 @@
+import { VegaInternalIconManager } from '../../../../../../helpers/icon/internal-icon-manager';
+import { DomNodeSubjectObserverFactory } from '../../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
+import { VegaChange, VegaClick, VegaPopoverHide, VegaPopoverShow, } from '../../../../../../helpers/event-manager/event-id/vega-event-id';
+import { VegaRTEToolbarButtonRenderer } from '../../../base-toolbar-button-renderer';
+import findReplaceIcon from '../../assets/find-and-replace';
+import { createFindReplaceControllerContext, } from '../controllers/find-replace-controller.abstract';
+import { FindController } from '../controllers/find-controller';
+import { ReplaceController } from '../controllers/replace-controller';
+import { VegaInternalTranslation } from '../../../../../../helpers/translation/internal-translation-controller';
+import { debounce } from '../../../../../../utils/timer';
+/**
+ * Toolbar button renderer for the Find & Replace extension.
+ *
+ * Responsible only for UI concerns:
+ * - Renders the toolbar button wrapped in a vega-popover.
+ * - Wires panel events to the {@link FindController} and {@link ReplaceController}.
+ * - Pushes controller results back to the panel display.
+ *
+ * Both controllers share a single {@link FindReplaceControllerContext} so they
+ * operate on the same search state and highlight overlays.
+ */
+export class FindReplaceToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  constructor() {
+    super(...arguments);
+    this.sharedContext = createFindReplaceControllerContext();
+    this.findController = new FindController(this.sharedContext);
+    this.replaceController = new ReplaceController(this.sharedContext);
+    this.panelRef = null;
+    this.popoverRef = null;
+    this.isPopoverOpen = false;
+    this.scrollOnNextRefresh = false;
+    this.debouncedRefresh = debounce(this.onContentChanged, 100, this);
+    /* eslint-disable jsdoc/require-jsdoc */
+    this.panelActionHandlers = {
+      'find': () => this.findController.find(),
+      'prev': () => this.findController.prev(),
+      'next': () => this.findController.next(),
+      'replace': () => {
+        this.scrollOnNextRefresh = true;
+        return this.replaceController.replace();
+      },
+      'replace-all': () => {
+        this.scrollOnNextRefresh = true;
+        return this.replaceController.replaceAll();
+      },
+      'match-case': (data) => this.findController.setMatchCase(data),
+      'whole-words': (data) => this.findController.setWholeWords(data),
+      'close': () => this.closePanel(),
+    };
+  }
+  /* eslint-enable jsdoc/require-jsdoc */
+  /**
+   * @inheritDoc
+   */
+  render(h, editorContext) {
+    this.syncEditorState(editorContext);
+    return h('vega-popover', {
+      trigger: 'none',
+      alignment: 'start',
+      placement: 'bottom',
+      showArrow: false,
+      isScreenPosition: true,
+      // eslint-disable-next-line jsdoc/require-jsdoc
+      ref: (ref) => {
+        if (ref) {
+          this.popoverRef = ref;
+          DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverHide, () => {
+            this.isPopoverOpen = false;
+            this.findController.clear();
+            this.updatePanel({ current: 0, total: 0 });
+          });
+          DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaPopoverShow, () => {
+            this.isPopoverOpen = true;
+          });
+        }
+      },
+    }, [
+      h('div', { slot: 'popover' }, [
+        h('vega-rich-text-find-replace-panel', {
+          // eslint-disable-next-line jsdoc/require-jsdoc
+          ref: (ref) => {
+            if (ref) {
+              this.panelRef = ref;
+              DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, (e) => {
+                if (e.detail.type === 'keyword') {
+                  this.updatePanel(this.findController.setKeyword(e.detail.value));
+                }
+                else if (e.detail.type === 'replace') {
+                  this.replaceController.setReplacement(e.detail.value);
+                }
+              });
+              DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaClick, (payload) => {
+                this.handlePanelAction(payload.detail);
+              });
+            }
+          },
+        }),
+      ]),
+      h('div', { slot: 'popover-content' }, this.renderButton(h, editorContext, {
+        icon: 'rte-find-replace',
+        tooltip: { text: VegaInternalTranslation.t('Find and replace') },
+      })),
+    ]);
+  }
+  /**
+   * Toggles the popover open/close when the toolbar button is clicked.
+   */
+  handleButtonClick() {
+    if (this.popoverRef) {
+      if (this.isPopoverOpen) {
+        void this.popoverRef.hide();
+      }
+      else {
+        void this.popoverRef.show();
+      }
+    }
+  }
+  /* istanbul ignore next */
+  /**
+   * Not used — this button has no dropdown.
+   */
+  handleDropdownClick() {
+    // no-op
+  }
+  // ─── Private helpers ──────────────────────────────────────────────────────────
+  /**
+   * Synchronizes internal state with the editor context on each render cycle.
+   * Registers the host reference and content-change listener, and hides the
+   * popover if the toolbar item becomes hidden while open.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context.
+   */
+  syncEditorState(editorContext) {
+    this.findController.setHost(editorContext.host);
+    const extensionContext = this.getExtensionContext(editorContext.host);
+    if (extensionContext) {
+      this.replaceController.setFlushValue(extensionContext.flushValue);
+    }
+    DomNodeSubjectObserverFactory.addUniqueObserverToNode(editorContext.host, VegaChange, this.debouncedRefresh);
+    if (this.isHidden(editorContext) && this.isPopoverOpen && this.popoverRef) {
+      void this.popoverRef.hide();
+    }
+  }
+  /**
+   * Dispatches panel button actions to the controller.
+   *
+   * @param {FindReplacePanelAction} panelAction - The structured action emitted by the panel.
+   */
+  handlePanelAction(panelAction) {
+    const { action, data } = panelAction;
+    const handler = this.panelActionHandlers[action];
+    if (handler) {
+      const result = handler(data);
+      if (result) {
+        this.updatePanel(result);
+      }
+    }
+  }
+  /**
+   * Pushes result to the panel counter display.
+   *
+   * @param {FindReplaceResult} result - The current/total values.
+   */
+  updatePanel(result) {
+    if (this.panelRef) {
+      void this.panelRef.updateResult(result.current, result.total);
+    }
+  }
+  /**
+   * Content changed — ask the controller to refresh search results.
+   */
+  onContentChanged() {
+    if (!this.isPopoverOpen) {
+      return;
+    }
+    const shouldScroll = this.scrollOnNextRefresh;
+    this.scrollOnNextRefresh = false;
+    const result = this.findController.refresh(shouldScroll);
+    if (result) {
+      this.updatePanel(result);
+    }
+  }
+  /**
+   * Closes the panel popover.
+   */
+  closePanel() {
+    if (this.popoverRef) {
+      void this.popoverRef.hide();
+    }
+  }
+}
+(() => {
+  VegaInternalIconManager.register({ 'rte-find-replace': findReplaceIcon });
+})();

package/dist/collection/components/vega-rich-text-editor/extensions/find-replace/vega-rich-text-find-replace-panel/slimmers/renderers/find-replace-panel-renderer.js

@@ -0,0 +1,153 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { h } from '@stencil/core';
+import { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
+import { VegaInternalIconManager } from '../../../../../../../helpers/icon/internal-icon-manager';
+import chevronUp from '../../../../../../../global/icons/chevron-up';
+import chevronDown from '../../../../../../../global/icons/chevron-down';
+import xmarkLarge from '../../../../../../../global/icons/xmark-large';
+import { DomNodeSubjectObserverFactory } from '../../../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-observer-factory';
+import { VegaChange, VegaClick } from '../../../../../../../helpers/event-manager/event-id/vega-event-id';
+import { VegaInternalTranslation } from '../../../../../../../helpers/translation/internal-translation-controller';
+/**
+ * Renderer slimmer for the Find & Replace panel.
+ * Renders a search input, a "current/total" counter, and prev/next/close icon buttons.
+ */
+export class FindReplacePanelRenderer extends VegaSlimmer {
+  render() {
+    const hasResults = this.total > 0;
+    return (h("div", { class: "find-replace-panel", role: "presentation" },
+      this.renderHeader(),
+      h("vega-divider", { direction: "horizontal" }),
+      h("div", { class: "find-replace-panel__field" },
+        h("vega-field-label", { label: VegaInternalTranslation.t('Find in text') }),
+        h("div", { class: "find-replace-panel__body" },
+          h("vega-input", { size: "small", label: "", class: "find-replace-panel__input", ref: (ref) => {
+              if (ref) {
+                DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, (e) => {
+                  this.onKeywordChange(e.detail);
+                });
+              }
+            } }),
+          h("vega-flex", { alignItems: "center", gap: "size-4", class: "find-replace-panel__nav" },
+            h("vega-font", { variant: "font-field-label-sm", color: "text-secondary", class: "find-replace-panel__counter" }, hasResults ? `${this.currentIndex}/${this.total}` : '-/-'),
+            this.renderNavButton('prev', 'rte-find-replace-prev', VegaInternalTranslation.t('Previous match')),
+            this.renderNavButton('next', 'rte-find-replace-next', VegaInternalTranslation.t('Next match'))))),
+      h("div", { class: "find-replace-panel__field" },
+        h("vega-field-label", { label: VegaInternalTranslation.t('Replace with') }),
+        h("div", { class: "find-replace-panel__body" },
+          h("vega-input", { disabled: !hasResults, size: "small", label: "", class: "find-replace-panel__input", ref: (ref) => {
+              if (ref) {
+                DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, (e) => {
+                  this.onReplacementChange(e.detail);
+                });
+              }
+            } }))),
+      h("vega-accordion", { class: "find-replace-panel__field", expand: false, drawsBackground: false },
+        h("div", { class: "find-replace-panel__accordion-title", slot: "title" }, VegaInternalTranslation.t('Advanced options')),
+        h("vega-flex", { slot: "content", gap: "size-16", class: "advanced-options-content" },
+          this.renderSearchOptionToggle('match-case', VegaInternalTranslation.t('Match case'), this.matchCase),
+          this.renderSearchOptionToggle('whole-words', VegaInternalTranslation.t('Whole words'), this.wholeWords))),
+      h("div", { class: "find-replace-panel__footer" }, this.renderActionButtons())));
+  }
+  renderHeader() {
+    return (h("div", { class: "find-replace-panel__header" },
+      h("vega-font", null, VegaInternalTranslation.t('Find and replace')),
+      this.renderNavButton('close', 'rte-find-replace-close', VegaInternalTranslation.t('Close'), 'extra-small')));
+  }
+  renderNavButton(itemKey, iconKey, label, size) {
+    return (h("vega-button-circle", { ref: (ref) => {
+        if (ref) {
+          DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaClick, () => {
+            this.emitAction(itemKey);
+          });
+        }
+      }, variant: "icon-only", size: size || 'small', icon: VegaInternalIconManager.getIconKey(iconKey), label: label }));
+  }
+  renderSearchOptionToggle(actionKey, label, isActive) {
+    return (h("vega-toggle-switch", { size: "small", label: label, checked: isActive, ref: (ref) => {
+        if (ref) {
+          DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaChange, () => {
+            this.onToggleSearchOption(actionKey);
+          });
+        }
+      } }));
+  }
+  renderFindButton() {
+    return (h("vega-button", { size: "small", variant: "secondary", ref: (ref) => {
+        if (ref) {
+          DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaClick, () => {
+            this.emitAction('find');
+          });
+        }
+      } }, VegaInternalTranslation.t('Find')));
+  }
+  renderActionButtons() {
+    const shouldDisableReplace = this.total === 0;
+    return (h("vega-flex", { alignItems: "center", gap: "size-16" },
+      h("vega-button-link", { size: "small", disabled: shouldDisableReplace, ref: (ref) => {
+          if (ref) {
+            DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaClick, () => {
+              this.emitAction('replace-all');
+            });
+          }
+        } }, VegaInternalTranslation.t('Replace All')),
+      h("vega-button-link", { size: "small", disabled: shouldDisableReplace, ref: (ref) => {
+          if (ref) {
+            DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, VegaClick, () => {
+              this.emitAction('replace');
+            });
+          }
+        } }, VegaInternalTranslation.t('Replace')),
+      this.renderFindButton()));
+  }
+  onKeywordChange(value) {
+    this.changeEventEmitter.emit({ type: 'keyword', value });
+  }
+  onReplacementChange(value) {
+    this.changeEventEmitter.emit({ type: 'replace', value });
+  }
+  onToggleSearchOption(actionKey) {
+    if (actionKey === 'match-case') {
+      this.matchCase = !this.matchCase;
+      this.emitAction(actionKey, this.matchCase);
+    }
+    else if (actionKey === 'whole-words') {
+      this.wholeWords = !this.wholeWords;
+      this.emitAction(actionKey, this.wholeWords);
+    }
+  }
+  emitAction(action, data) {
+    const payload = data !== undefined ? { action, data } : { action };
+    this.clickEventEmitter.emit(payload);
+  }
+}
+(() => {
+  VegaInternalIconManager.register({
+    'rte-find-replace-prev': chevronUp,
+    'rte-find-replace-next': chevronDown,
+    'rte-find-replace-close': xmarkLarge,
+  });
+})();
+__decorate([
+  MapToComponentField()
+], FindReplacePanelRenderer.prototype, "changeEventEmitter", void 0);
+__decorate([
+  MapToComponentField()
+], FindReplacePanelRenderer.prototype, "clickEventEmitter", void 0);
+__decorate([
+  MapToComponentField()
+], FindReplacePanelRenderer.prototype, "currentIndex", void 0);
+__decorate([
+  MapToComponentField()
+], FindReplacePanelRenderer.prototype, "total", void 0);
+__decorate([
+  MapToComponentField({ writable: true })
+], FindReplacePanelRenderer.prototype, "matchCase", void 0);
+__decorate([
+  MapToComponentField({ writable: true })
+], FindReplacePanelRenderer.prototype, "wholeWords", void 0);

package/dist/collection/components/vega-rich-text-editor/extensions/find-replace/vega-rich-text-find-replace-panel/vega-rich-text-find-replace-panel.css

@@ -0,0 +1,50 @@
+/* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */ /* This file is generated by vega-design 2.0.77 */
+/**
+ * Deprecated. Not for use in new websites.
+ * https://developer.mozilla.org/en-US/docs/Web/CSS/word-break#break-word
+ */
+:host .find-replace-panel {
+  box-sizing: border-box;
+  width: 360px;
+}
+:host .find-replace-panel__header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding-bottom: 12px;
+}
+:host .find-replace-panel__field {
+  padding-top: 12px;
+}
+:host .find-replace-panel__body {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 8px;
+}
+:host .find-replace-panel__input {
+  flex: 1;
+}
+:host .find-replace-panel__nav {
+  flex-shrink: 0;
+}
+:host .find-replace-panel__counter {
+  white-space: nowrap;
+  min-width: 36px;
+  text-align: center;
+}
+:host .find-replace-panel__footer {
+  display: flex;
+  justify-content: flex-end;
+  padding-top: 20px;
+}
+:host .advanced-options-content {
+  margin-top: -12px;
+}
+:host .find-replace-panel__accordion-title {
+  font-size: 16px;
+  font-weight: 500;
+  color: rgba(var(--v-text-primary, 32, 54, 69, 1));
+  line-height: 22px;
+  padding: 0;
+}

package/dist/collection/components/vega-rich-text-editor/extensions/find-replace/vega-rich-text-find-replace-panel/vega-rich-text-find-replace-panel.js

@@ -0,0 +1,156 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Component, Element, Event, h, Host, Method, State } from '@stencil/core';
+import { InjectVegaGlobalSlimmer, InjectVegaSlimmer } from 'vega-slimmer/core';
+import { sanitizeVegaComponent } from '../../../../../utils/component';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../../../helpers/slimmers/component-usage-runtime-metrics';
+import { createEventEmitSlimmer, } from '../../../../../helpers/event-manager/slimmers/event-emit-slimmer';
+import { VegaChange, VegaClick } from '../../../../../helpers/event-manager/event-id/vega-event-id';
+import { FindReplacePanelRenderer } from './slimmers/renderers/find-replace-panel-renderer';
+/**
+ * Internal panel component for the Find & Replace extension.
+ * Renders a search input, match counter, and prev/next/close buttons.
+ *
+ * - Emits `vegaChange` (payload: { type, value }) when find/replace inputs change.
+ * - Emits `vegaClick` (payload: `{ action: string; data?: unknown }`) when a button is clicked.
+ * - Exposes `updateResult(currentIndex, total)` for the toolbar renderer to push match counts back.
+ *
+ * @vegaVersion 2.92.0
+ */
+export class VegaRichTextFindReplacePanel {
+  constructor() {
+    this.globalSlimmers = {};
+    this.vegaComponentUsageRuntimeMetricsSlimmer = new VegaComponentUsageRuntimeMetricsSlimmer();
+    this.changeEventEmitter = createEventEmitSlimmer(VegaRichTextFindReplacePanel, VegaChange);
+    this.clickEventEmitter = createEventEmitSlimmer(VegaRichTextFindReplacePanel, VegaClick);
+    this.renderer = new FindReplacePanelRenderer();
+    this.currentIndex = 0;
+    this.total = 0;
+    this.matchCase = false;
+    this.wholeWords = false;
+  }
+  /**
+   * Updates the displayed match counter. Called by the toolbar renderer after each search or navigation.
+   *
+   * @param {number} currentIndex - 1-based index of the active match (0 when there are no matches).
+   * @param {number} total - Total number of matches.
+   * @vegaVersion 2.92.0
+   */
+  async updateResult(currentIndex, total) {
+    this.currentIndex = currentIndex;
+    this.total = total;
+  }
+  render() {
+    return sanitizeVegaComponent(h(Host, null, this.renderer.render()), this.host);
+  }
+  static get is() { return "vega-rich-text-find-replace-panel"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() { return {
+    "$": ["vega-rich-text-find-replace-panel.scss"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["vega-rich-text-find-replace-panel.css"]
+  }; }
+  static get states() { return {
+    "currentIndex": {},
+    "total": {},
+    "matchCase": {},
+    "wholeWords": {}
+  }; }
+  static get events() { return [{
+      "method": "vegaChange",
+      "name": "vegaChange",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [{
+            "name": "vegaVersion",
+            "text": "2.92.0"
+          }],
+        "text": "Emitted when a panel input value changes.\nPayload includes the input type (`keyword` or `replace`) and value."
+      },
+      "complexType": {
+        "original": "{ type: 'keyword' | 'replace'; value: string }",
+        "resolved": "{ type: \"keyword\" | \"replace\"; value: string; }",
+        "references": {}
+      }
+    }, {
+      "method": "vegaClick",
+      "name": "vegaClick",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [{
+            "name": "vegaVersion",
+            "text": "2.92.0"
+          }],
+        "text": "Emitted when a panel action button is clicked.\nPayload includes the action key and optional data."
+      },
+      "complexType": {
+        "original": "{ action: string; data?: unknown }",
+        "resolved": "{ action: string; data?: unknown; }",
+        "references": {}
+      }
+    }]; }
+  static get methods() { return {
+    "updateResult": {
+      "complexType": {
+        "signature": "(currentIndex: number, total: number) => Promise<void>",
+        "parameters": [{
+            "tags": [{
+                "name": "param",
+                "text": "currentIndex - 1-based index of the active match (0 when there are no matches)."
+              }],
+            "text": "- 1-based index of the active match (0 when there are no matches)."
+          }, {
+            "tags": [{
+                "name": "param",
+                "text": "total - Total number of matches."
+              }],
+            "text": "- Total number of matches."
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "Updates the displayed match counter. Called by the toolbar renderer after each search or navigation.",
+        "tags": [{
+            "name": "param",
+            "text": "currentIndex - 1-based index of the active match (0 when there are no matches)."
+          }, {
+            "name": "param",
+            "text": "total - Total number of matches."
+          }, {
+            "name": "vegaVersion",
+            "text": "2.92.0"
+          }]
+      }
+    }
+  }; }
+  static get elementRef() { return "host"; }
+}
+__decorate([
+  InjectVegaGlobalSlimmer()
+], VegaRichTextFindReplacePanel.prototype, "globalSlimmers", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaRichTextFindReplacePanel.prototype, "vegaComponentUsageRuntimeMetricsSlimmer", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaRichTextFindReplacePanel.prototype, "changeEventEmitter", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaRichTextFindReplacePanel.prototype, "clickEventEmitter", void 0);
+__decorate([
+  InjectVegaSlimmer()
+], VegaRichTextFindReplacePanel.prototype, "renderer", void 0);

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

@@ -40,7 +40,7 @@ export class VegaRTEFunctionExtension extends VegaRTEExtension {
   }
   /** @inheritDoc */
   prepareBeforeLoad(host) {
-    this.registerToolbarButtonRenderer('functions', new FunctionToolbarButtonRenderer(), host);
+    this.registerToolbarButtonRenderer(VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY, new FunctionToolbarButtonRenderer(), host);
   }
   /**
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
@@ -64,3 +64,4 @@ export class VegaRTEFunctionExtension extends VegaRTEExtension {
   VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.INSERT_NEW_PARAGRAPH, new PreventNewParagraphInterceptor());
   VegaRTEExtension.registerActionHandlerInterceptor(RTETextBlock.name, ModifyContentActionType.PASTE_CONTENT, new PreventPasteContentInterceptor());
 })();
+VegaRTEFunctionExtension.TOOLBAR_BUTTON_KEY = 'functions';