@globalpayments/vega 2.96.0 → 2.98.0

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/controllers/link-editor-controller.js

@@ -0,0 +1,398 @@
+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 { forceUpdate } from '@stencil/core';
+import { MapToComponentField, MapToComponentMethod, VegaSlimmer } from 'vega-slimmer/core';
+import { waitForComponentDidRender } from '../../../../../helpers/common/wait-for-component-did-render';
+import { VegaInternalComponentDidRender, VegaInternalPopoverUpdateTarget, } from '../../../../../helpers/event-manager/event-id/vega-internal-event-id';
+import domNodeSubjectFactory from '../../../../../helpers/change-manager/subject/dom-node-subject/dom-node-subject-factory';
+import ChangeManager from '../../../../../helpers/change-manager/change-manager';
+import remoteInvocationRegistry from '../../../../../helpers/remote-invocation/remote-invocation-registry';
+import { LINK_TYPE_HANDLER_MAP } from '../renderers/link-type-handler';
+import { LinkUrlNormalizer } from '../utils/link-url-normalizer';
+import { RTE_DEFAULT_LINK_TYPE_KEY, RTE_EMAIL_LINK_TYPE_KEY } from '../../../constants/constant';
+/**
+ * Coordinates link editor state, popover behavior, and submit actions.
+ */
+export class LinkEditorController extends VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    this.linkUrlNormalizer = new LinkUrlNormalizer();
+    this.linkTypeHandlers = LINK_TYPE_HANDLER_MAP;
+  }
+  /** Initializes the popover target after the component loads. */
+  componentDidLoad() {
+    this.updatePopoverTarget();
+  }
+  /** Notifies observers after each render cycle. */
+  componentDidRender() {
+    ChangeManager.notify(domNodeSubjectFactory.getSubject(this.host, VegaInternalComponentDidRender), {});
+  }
+  /** Focuses the URL input when the status changes to linkEdit. */
+  watchStatusChange() {
+    if (this.status === 'linkEdit') {
+      setTimeout(() => {
+        var _a;
+        void ((_a = this.renderer.getUrlInputRef()) === null || _a === void 0 ? void 0 : _a.doFocus());
+      });
+    }
+  }
+  /** Invalidates link type cache and updates the popover target when the target changes. */
+  watchTargetChange() {
+    this.linkTypeConfigController.invalidateConfiguredLinkTypesCache();
+    this.updatePopoverTarget();
+  }
+  /**
+   * Prepares the editor state before the popover is shown.
+   *
+   * @returns {Promise<void>} Resolves when the popover show work completes.
+   * Resolves when the popover show work completes.
+   */
+  async handlePopoverShow() {
+    var _a, _b, _c, _d;
+    this.linkTypeConfigController.invalidateConfiguredLinkTypesCache();
+    this.linkEditorStateManager.clearFormValues();
+    if (this.linkEditorStateManager.getShouldResetStatusOnNextShow()) {
+      this.linkEditorStateManager.setShouldResetStatusOnNextShow(false);
+      if (this.status !== 'editOrUnlinkSelection') {
+        this.status = 'editOrUnlinkSelection';
+        forceUpdate(this.host);
+        await this.waitForRender();
+      }
+    }
+    if (this.status === 'linkEdit') {
+      const resolvedKey = this.linkTypeConfigController.resolveInitialLinkTypeKey((_a = this.record) === null || _a === void 0 ? void 0 : _a.linkType, (_b = this.record) === null || _b === void 0 ? void 0 : _b.url);
+      if (resolvedKey !== this.linkEditorStateManager.getSelectedLinkTypeKey()) {
+        this.linkEditorStateManager.setSelectedLinkTypeKey(resolvedKey);
+        this.linkEditorStateManager.setSubmitDisabled(true);
+        await ((_d = (_c = this.renderer.getFormRef()) === null || _c === void 0 ? void 0 : _c.reset) === null || _d === void 0 ? void 0 : _d.call(_c));
+        forceUpdate(this.host);
+        await this.waitForRender();
+      }
+      await this.populateEditForm();
+    }
+  }
+  /**
+   * Clears form state after the popover hides.
+   *
+   * @returns {void} No return value.
+   */
+  handlePopoverHide() {
+    var _a, _b;
+    void ((_b = (_a = this.renderer.getFormRef()) === null || _a === void 0 ? void 0 : _a.reset) === null || _b === void 0 ? void 0 : _b.call(_a));
+    this.linkEditorStateManager.clearFormValues();
+    if (this.linkTypeConfigController.hasConfiguredLinkTypes()) {
+      this.updateSubmitDisabledState('');
+    }
+    if (this.resetStatusAfterHide) {
+      this.linkEditorStateManager.setShouldResetStatusOnNextShow(true);
+    }
+  }
+  /**
+   * Switches the editor into link edit mode.
+   *
+   * @returns {void} No return value.
+   */
+  handleEditAction() {
+    var _a, _b;
+    this.linkEditorStateManager.setSelectedLinkTypeKey(this.linkTypeConfigController.resolveInitialLinkTypeKey((_a = this.record) === null || _a === void 0 ? void 0 : _a.linkType, (_b = this.record) === null || _b === void 0 ? void 0 : _b.url));
+    this.status = 'linkEdit';
+    forceUpdate(this.host);
+    void this.waitForRender().then(() => this.populateEditForm());
+  }
+  /**
+   * Removes the current selection link and closes the popover.
+   *
+   * @returns {Promise<void>} Resolves when unlinking finishes.
+   */
+  async handleUnlinkAction() {
+    this.changeEventEmitter.emit({ action: 'unlink' });
+    await this.renderer.getPopoverRef().hide();
+  }
+  /**
+   * Updates submit state from URL input changes.
+   *
+   * @param {CustomEvent<string>} e - URL input change event.
+   * @returns {void} No return value.
+   */
+  handleUrlVegaChange(e) {
+    if (this.linkTypeConfigController.hasConfiguredLinkTypes()) {
+      this.updateSubmitDisabledState(e.detail);
+    }
+  }
+  /**
+   * Submits the current link when Enter is pressed or hides the popover when Escape is pressed.
+   *
+   * @param {KeyboardEvent} e - Key down event.
+   * @returns {void} No return value.
+   */
+  handleKeyDown(e) {
+    if (e.key === 'Escape') {
+      void this.renderer.getPopoverRef().hide();
+      return;
+    }
+    if (e.key === 'Enter') {
+      if (this.linkTypeConfigController.hasConfiguredLinkTypes() &&
+        this.linkEditorStateManager.getIsSubmitDisabled()) {
+        return;
+      }
+      void this.submitLink();
+    }
+  }
+  /**
+   * Switches the active form when the link type changes.
+   *
+   * @param {NotifyObserverPayload<string>} payload - Selected link type change payload.
+   * @returns {Promise<void>} Resolves when the link type switch completes.
+   */
+  async handleLinkTypeChange(payload) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const previousLinkTypeKey = this.linkEditorStateManager.getSelectedLinkTypeKey();
+    const nextLinkTypeKey = payload.detail ||
+      ((_a = this.linkTypeConfigController.getConfiguredLinkTypes()[0]) === null || _a === void 0 ? void 0 : _a.key) ||
+      RTE_DEFAULT_LINK_TYPE_KEY;
+    if (previousLinkTypeKey === nextLinkTypeKey) {
+      return;
+    }
+    const currentFormValues = (_d = (await ((_c = (_b = this.renderer.getFormRef()) === null || _b === void 0 ? void 0 : _b.getValue) === null || _c === void 0 ? void 0 : _c.call(_b)))) !== null && _d !== void 0 ? _d : {};
+    const currentSharedTextValue = (_e = currentFormValues.text) !== null && _e !== void 0 ? _e : this.linkEditorStateManager.getSharedTextValue();
+    this.linkEditorStateManager.setSharedTextValue(currentSharedTextValue);
+    const currentTypeValues = Object.assign({}, currentFormValues);
+    delete currentTypeValues.text;
+    const hasAnyValue = Object.values(currentTypeValues).some((value) => value);
+    if (hasAnyValue) {
+      this.linkEditorStateManager.cacheFormValues(previousLinkTypeKey, currentTypeValues);
+    }
+    const savedValues = this.linkEditorStateManager.getCachedFormValues(nextLinkTypeKey);
+    this.linkEditorStateManager.setSelectedLinkTypeKey(nextLinkTypeKey);
+    this.linkEditorStateManager.setSubmitDisabled(true);
+    forceUpdate(this.host);
+    if (savedValues && ((_f = this.renderer.getFormRef()) === null || _f === void 0 ? void 0 : _f.setValue)) {
+      void this.waitForRender().then(() => this.performFormRestore(Object.assign(Object.assign({}, savedValues), { text: this.linkEditorStateManager.getSharedTextValue() })));
+      return;
+    }
+    await ((_h = (_g = this.renderer.getFormRef()) === null || _g === void 0 ? void 0 : _g.reset) === null || _h === void 0 ? void 0 : _h.call(_g));
+    void this.waitForRender().then(() => { var _a; return (_a = this.renderer.getUrlInputRef()) === null || _a === void 0 ? void 0 : _a.doFocus(); });
+    const sharedTextValue = this.linkEditorStateManager.getSharedTextValue();
+    await ((_k = (_j = this.renderer.getFormRef()) === null || _j === void 0 ? void 0 : _j.setValue) === null || _k === void 0 ? void 0 : _k.call(_j, { text: sharedTextValue }));
+    this.syncTextInputValue(sharedTextValue);
+  }
+  /**
+   * Builds and emits the final link payload.
+   *
+   * @returns {Promise<void>} Resolves when the link submit flow completes.
+   */
+  async submitLink() {
+    var _a, _b, _c, _d;
+    const formValues = (_c = (await ((_b = (_a = this.renderer.getFormRef()) === null || _a === void 0 ? void 0 : _a.getValue) === null || _b === void 0 ? void 0 : _b.call(_a)))) !== null && _c !== void 0 ? _c : {};
+    const selectedLinkTypeKey = this.linkEditorStateManager.getSelectedLinkTypeKey();
+    const handler = this.linkTypeHandlers.get(selectedLinkTypeKey);
+    if (!handler) {
+      return;
+    }
+    const deps = {
+      normalizeUrl: this.normalizeUrlByDefaultProtocol.bind(this),
+      buildEmailUrl: this.buildEmailLinkUrl.bind(this),
+    };
+    const text = handler.getTextValue(formValues);
+    let normalizedUrl = handler.buildFinalUrl(formValues, deps);
+    normalizedUrl = this.preserveExistingMailtoUrlIfUnchanged(formValues, normalizedUrl);
+    if (normalizedUrl.length === 0) {
+      if ((_d = this.record) === null || _d === void 0 ? void 0 : _d.url) {
+        this.changeEventEmitter.emit({ action: 'unlink' });
+        await this.renderer.getPopoverRef().hide();
+      }
+      return;
+    }
+    if (normalizedUrl.length > 0) {
+      this.changeEventEmitter.emit({
+        action: 'link',
+        payload: Object.assign({ text: text || handler.getFallbackText(formValues) || normalizedUrl, url: normalizedUrl }, (this.linkTypeConfigController.hasConfiguredLinkTypes()
+          ? { linkType: selectedLinkTypeKey }
+          : {})),
+      });
+      await this.renderer.getPopoverRef().hide();
+    }
+  }
+  /**
+   * Populates the edit form from the active record.
+   *
+   * @returns {Promise<void>} Resolves when the edit form is populated.
+   */
+  async populateEditForm() {
+    var _a, _b, _c, _d, _e;
+    const handler = this.linkTypeHandlers.get(this.linkEditorStateManager.getSelectedLinkTypeKey());
+    if (!handler) {
+      return;
+    }
+    const deps = {
+      parseMailtoUrl: this.parseMailtoUrl.bind(this),
+      normalizeUrl: this.normalizeUrlByDefaultProtocol.bind(this),
+    };
+    const requiredValue = this.linkTypeConfigController.hasConfiguredLinkTypes()
+      ? handler.getRequiredValue(this.record, deps)
+      : '';
+    const initialFormValues = handler.getInitialFormValues(this.record, deps);
+    this.linkEditorStateManager.setSharedTextValue(initialFormValues.text || '');
+    await ((_b = (_a = this.renderer.getFormRef()) === null || _a === void 0 ? void 0 : _a.setValue) === null || _b === void 0 ? void 0 : _b.call(_a, initialFormValues));
+    this.syncTextInputValue(initialFormValues.text || '');
+    this.updateSubmitDisabledState(requiredValue);
+    await ((_d = (_c = this.renderer.getFormRef()) === null || _c === void 0 ? void 0 : _c.setValue) === null || _d === void 0 ? void 0 : _d.call(_c, handler.getInitialFormValues(this.record, deps)));
+    await ((_e = this.renderer.getUrlInputRef()) === null || _e === void 0 ? void 0 : _e.doFocus());
+  }
+  /**
+   * Updates the popover target via the remote invocation registry.
+   *
+   * @returns {void} No return value.
+   */
+  updatePopoverTarget() {
+    remoteInvocationRegistry.call(domNodeSubjectFactory.getSubject(this.renderer.getPopoverRef(), VegaInternalPopoverUpdateTarget), this.target);
+  }
+  /**
+   * Preserves an unchanged mailto URL when the form edits are equivalent.
+   *
+   * @param {Record<string, string>} formValues - Current form values.
+   * @param {string} normalizedUrl - Normalized URL candidate.
+   * @returns {string} The preserved or normalized URL.
+   */
+  preserveExistingMailtoUrlIfUnchanged(formValues, normalizedUrl) {
+    var _a;
+    if (this.linkEditorStateManager.getSelectedLinkTypeKey() !== RTE_EMAIL_LINK_TYPE_KEY ||
+      !((_a = this.record) === null || _a === void 0 ? void 0 : _a.url)) {
+      return normalizedUrl;
+    }
+    const existingUrl = this.record.url;
+    if (!existingUrl.startsWith('mailto:')) {
+      return normalizedUrl;
+    }
+    const existingMailto = this.parseMailtoUrl(existingUrl);
+    const nextEmailAddress = (formValues.emailAddress || '').trim();
+    const nextSubject = (formValues.messageSubject || '').trim();
+    const nextBody = (formValues.messageBody || '').trim();
+    if (nextEmailAddress === existingMailto.emailAddress &&
+      nextSubject === existingMailto.subject &&
+      nextBody === existingMailto.body) {
+      return existingUrl;
+    }
+    return normalizedUrl;
+  }
+  /**
+   * Normalizes a URL using the currently selected link type protocol.
+   *
+   * @param {string} url - URL to normalize.
+   * @returns {string} The normalized URL.
+   */
+  normalizeUrlByDefaultProtocol(url) {
+    return this.linkUrlNormalizer.normalizeUrlByDefaultProtocol(url, this.linkTypeConfigController.getDefaultProtocolForLinkType(this.linkEditorStateManager.getSelectedLinkTypeKey()));
+  }
+  /**
+   * Parses a mailto URL into structured parts.
+   *
+   * @param {string} url - Mailto URL to parse.
+   * @returns {MailtoUrlParts} The parsed mailto parts.
+   */
+  parseMailtoUrl(url) {
+    return this.linkUrlNormalizer.parseMailtoUrl(url);
+  }
+  /**
+   * Builds a mailto URL from the email form fields.
+   *
+   * @param {string} emailAddress - Email address value.
+   * @param {string} subject - Subject value.
+   * @param {string} body - Body value.
+   * @returns {string} The generated mailto URL.
+   */
+  buildEmailLinkUrl(emailAddress, subject, body) {
+    return this.linkUrlNormalizer.buildEmailLinkUrl(emailAddress, subject, body);
+  }
+  /**
+   * Enables or disables submit based on the normalized URL value.
+   *
+   * @param {string} url - URL value to evaluate.
+   * @returns {void} No return value.
+   */
+  updateSubmitDisabledState(url) {
+    const nextDisabled = this.normalizeUrlByDefaultProtocol(url).length === 0;
+    if (this.linkEditorStateManager.getIsSubmitDisabled() !== nextDisabled) {
+      this.linkEditorStateManager.setSubmitDisabled(nextDisabled);
+      forceUpdate(this.host);
+    }
+  }
+  /**
+   * Restores cached form values after the next render.
+   *
+   * @param {Record<string, string>} savedValues - Link type-specific values to restore.
+   * @returns {Promise<void>} Resolves after restoring cached values.
+   */
+  async performFormRestore(savedValues) {
+    var _a, _b, _c, _d, _e;
+    await ((_b = (_a = this.renderer.getFormRef()) === null || _a === void 0 ? void 0 : _a.reset) === null || _b === void 0 ? void 0 : _b.call(_a));
+    await ((_d = (_c = this.renderer.getFormRef()) === null || _c === void 0 ? void 0 : _c.setValue) === null || _d === void 0 ? void 0 : _d.call(_c, savedValues));
+    this.syncTextInputValue(savedValues.text || '');
+    const restoredRequiredValue = savedValues.url || savedValues.emailAddress || '';
+    this.updateSubmitDisabledState(restoredRequiredValue);
+    await ((_e = this.renderer.getUrlInputRef()) === null || _e === void 0 ? void 0 : _e.doFocus());
+  }
+  /**
+   * Keeps text input UI in sync as a fallback when form setValue timing misses visual update.
+   *
+   * @param {string} textValue - Text value to display.
+   * @returns {void} No return value.
+   */
+  syncTextInputValue(textValue) {
+    const textInput = this.renderer.getTextInputRef();
+    if (textInput) {
+      textInput.value = textValue;
+    }
+  }
+  /**
+   * Waits for the host to finish rendering.
+   *
+   * @returns {Promise<unknown>} A promise that resolves after the host renders.
+   */
+  waitForRender() {
+    return waitForComponentDidRender(this.host);
+  }
+}
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "host", void 0);
+__decorate([
+  MapToComponentField({ writable: true })
+], LinkEditorController.prototype, "status", void 0);
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "record", void 0);
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "changeEventEmitter", void 0);
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "resetStatusAfterHide", void 0);
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "target", void 0);
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "renderer", void 0);
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "linkTypeConfigController", void 0);
+__decorate([
+  MapToComponentField()
+], LinkEditorController.prototype, "linkEditorStateManager", void 0);
+__decorate([
+  MapToComponentMethod('componentDidLoad')
+], LinkEditorController.prototype, "componentDidLoad", null);
+__decorate([
+  MapToComponentMethod('componentDidRender')
+], LinkEditorController.prototype, "componentDidRender", null);
+__decorate([
+  MapToComponentMethod('watchStatusChange')
+], LinkEditorController.prototype, "watchStatusChange", null);
+__decorate([
+  MapToComponentMethod('watchTargetChange')
+], LinkEditorController.prototype, "watchTargetChange", null);

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/controllers/link-editor-state-manager.js

@@ -0,0 +1,111 @@
+import { VegaSlimmer } from 'vega-slimmer/core';
+import { RTE_DEFAULT_LINK_TYPE_KEY } from '../../../constants/constant';
+/**
+ * Stores link editor state across popover interactions.
+ */
+export class LinkEditorStateManager extends VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    this.isSubmitDisabled = true;
+    this.selectedLinkTypeKey = RTE_DEFAULT_LINK_TYPE_KEY;
+    this.shouldResetStatusOnNextShow = false;
+    this.formValuesByType = new Map();
+    this.sharedTextValue = '';
+  }
+  /**
+   * Returns whether submit is currently disabled.
+   *
+   * @returns {boolean} True when submit is disabled.
+   */
+  getIsSubmitDisabled() {
+    return this.isSubmitDisabled;
+  }
+  /**
+   * Updates the submit disabled state.
+   *
+   * @param {boolean} isSubmitDisabled - Next disabled state.
+   * @returns {void} No return value.
+   */
+  setSubmitDisabled(isSubmitDisabled) {
+    this.isSubmitDisabled = isSubmitDisabled;
+  }
+  /**
+   * Returns the selected link type key.
+   *
+   * @returns {string} The selected link type key.
+   */
+  getSelectedLinkTypeKey() {
+    return this.selectedLinkTypeKey;
+  }
+  /**
+   * Updates the selected link type key.
+   *
+   * @param {string} selectedLinkTypeKey - Next link type key.
+   * @returns {void} No return value.
+   */
+  setSelectedLinkTypeKey(selectedLinkTypeKey) {
+    this.selectedLinkTypeKey = selectedLinkTypeKey;
+  }
+  /**
+   * Returns whether the status should reset on the next show.
+   *
+   * @returns {boolean} True when the next show should reset the status.
+   */
+  getShouldResetStatusOnNextShow() {
+    return this.shouldResetStatusOnNextShow;
+  }
+  /**
+   * Updates whether the status should reset on the next show.
+   *
+   * @param {boolean} shouldResetStatusOnNextShow - Next reset flag.
+   * @returns {void} No return value.
+   */
+  setShouldResetStatusOnNextShow(shouldResetStatusOnNextShow) {
+    this.shouldResetStatusOnNextShow = shouldResetStatusOnNextShow;
+  }
+  /**
+   * Clears all cached form values.
+   *
+   * @returns {void} No return value.
+   */
+  clearFormValues() {
+    this.formValuesByType.clear();
+    this.sharedTextValue = '';
+  }
+  /**
+   * Returns the text value shared across link types.
+   *
+   * @returns {string} Shared text value.
+   */
+  getSharedTextValue() {
+    return this.sharedTextValue;
+  }
+  /**
+   * Updates the text value shared across link types.
+   *
+   * @param {string} textValue - Next shared text value.
+   * @returns {void} No return value.
+   */
+  setSharedTextValue(textValue) {
+    this.sharedTextValue = textValue;
+  }
+  /**
+   * Stores form values for a given link type key.
+   *
+   * @param {string} linkTypeKey - Link type cache key.
+   * @param {Record<string, string>} formValues - Form values to cache.
+   * @returns {void} No return value.
+   */
+  cacheFormValues(linkTypeKey, formValues) {
+    this.formValuesByType.set(linkTypeKey, formValues);
+  }
+  /**
+   * Returns cached form values for a given link type key.
+   *
+   * @param {string} linkTypeKey - Link type cache key.
+   * @returns {Record<string, string> | undefined} The cached form values, if any.
+   */
+  getCachedFormValues(linkTypeKey) {
+    return this.formValuesByType.get(linkTypeKey);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/vega-rich-text-link-editor/slimmers/controllers/link-type-config-controller.js

@@ -0,0 +1,173 @@
+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 { MapToComponentField, VegaSlimmer } from 'vega-slimmer/core';
+import { findParent } from '../../../../../utils/ui';
+import { VegaRTELinkExtension } from '../../../extensions/link/link-extension';
+import { LINK_TYPE_HANDLER_MAP } from '../renderers/link-type-handler';
+import { RTE_DEFAULT_LINK_TYPE_KEY, RTE_EMAIL_LINK_TYPE_KEY, RTE_SUPPORTED_LINK_TYPE_KEYS, } from '../../../constants/constant';
+/**
+ * Resolves configured link types and their defaults.
+ */
+export class LinkTypeConfigController extends VegaSlimmer {
+  constructor() {
+    super(...arguments);
+    this.configuredLinkTypesCache = null;
+    this.linkTypeHandlers = LINK_TYPE_HANDLER_MAP;
+  }
+  /**
+   * Returns the configured link types, using a cache when available.
+   *
+   * @returns {VegaRTELinkType[]} The configured link types.
+   */
+  getConfiguredLinkTypes() {
+    if (this.configuredLinkTypesCache) {
+      return this.configuredLinkTypesCache;
+    }
+    const configuredLinkTypes = this.resolveConfiguredLinkTypes();
+    this.configuredLinkTypesCache = configuredLinkTypes;
+    return configuredLinkTypes;
+  }
+  /**
+   * Clears the cached configured link types.
+   *
+   * @returns {void} No return value.
+   */
+  invalidateConfiguredLinkTypesCache() {
+    this.configuredLinkTypesCache = null;
+  }
+  /**
+   * Resolves the initial link type key for the current record.
+   *
+   * @param {string} recordLinkType - Link type from the active record.
+   * @param {string} recordUrl - URL from the active record.
+   * @returns {string} The resolved initial link type key.
+   */
+  resolveInitialLinkTypeKey(recordLinkType, recordUrl) {
+    var _a;
+    const configuredLinkTypes = this.getConfiguredLinkTypes();
+    if (recordLinkType &&
+      configuredLinkTypes.some((item) => item.key === recordLinkType)) {
+      return recordLinkType;
+    }
+    const normalizedRecordUrl = (recordUrl || '').trim().toLowerCase();
+    if (normalizedRecordUrl.startsWith('mailto:') &&
+      configuredLinkTypes.some((item) => item.key === RTE_EMAIL_LINK_TYPE_KEY)) {
+      return RTE_EMAIL_LINK_TYPE_KEY;
+    }
+    return ((_a = configuredLinkTypes[0]) === null || _a === void 0 ? void 0 : _a.key) || RTE_DEFAULT_LINK_TYPE_KEY;
+  }
+  /**
+   * Returns whether any configured link types are available.
+   *
+   * @returns {boolean} True when configured link types exist.
+   */
+  hasConfiguredLinkTypes() {
+    return this.getConfiguredLinkTypes().length > 0;
+  }
+  /**
+   * Returns the default protocol for a given link type key.
+   *
+   * @param {string} selectedLinkTypeKey - Selected link type key.
+   * @returns {string | undefined} The default protocol, if configured.
+   */
+  getDefaultProtocolForLinkType(selectedLinkTypeKey) {
+    var _a;
+    const linkConfig = this.getLinkConfig();
+    const selectedLinkType = this.getConfiguredLinkTypes().find((item) => item.key === selectedLinkTypeKey);
+    return (_a = selectedLinkType === null || selectedLinkType === void 0 ? void 0 : selectedLinkType.defaultProtocol) !== null && _a !== void 0 ? _a : linkConfig.defaultProtocol;
+  }
+  /**
+   * Returns the active link configuration for the current editor host.
+   *
+   * @returns {VegaRTELinkExtensionConfig} The active link configuration.
+   */
+  getLinkConfig() {
+    const rteHost = findParent(this.host, 'vega-rich-text-editor');
+    return VegaRTELinkExtension.configStore.get(rteHost) || {};
+  }
+  /**
+   * Normalizes configured link types and filters unsupported entries.
+   *
+   * @returns {VegaRTELinkType[]} The normalized configured link types.
+   */
+  resolveConfiguredLinkTypes() {
+    const linkConfig = this.getLinkConfig();
+    const configLinkTypes = linkConfig.linkTypes || [];
+    const normalizedByKey = new Map();
+    configLinkTypes.forEach((item) => {
+      const key = item.key.trim();
+      if (!key || !LinkTypeConfigController.SUPPORTED_LINK_TYPE_KEYS.has(key)) {
+        return;
+      }
+      if (!normalizedByKey.has(key)) {
+        normalizedByKey.set(key, this.normalizeSupportedLinkType(item, key, linkConfig.defaultProtocol));
+      }
+    });
+    if (normalizedByKey.size === 0) {
+      return [];
+    }
+    if (normalizedByKey.has(RTE_EMAIL_LINK_TYPE_KEY)) {
+      return [
+        normalizedByKey.get(RTE_DEFAULT_LINK_TYPE_KEY) ||
+          this.createDefaultUrlLinkType(linkConfig.defaultProtocol),
+        normalizedByKey.get(RTE_EMAIL_LINK_TYPE_KEY),
+      ];
+    }
+    return [
+      normalizedByKey.get(RTE_DEFAULT_LINK_TYPE_KEY) ||
+        this.createDefaultUrlLinkType(linkConfig.defaultProtocol),
+    ];
+  }
+  /**
+   * Creates the default URL link type descriptor.
+   *
+   * @param {string} configDefaultProtocol - Default protocol from config.
+   * @returns {VegaRTELinkType} The default URL link type descriptor.
+   */
+  createDefaultUrlLinkType(configDefaultProtocol) {
+    const normalizedConfigDefaultProtocol = (configDefaultProtocol || '').trim();
+    return {
+      key: RTE_DEFAULT_LINK_TYPE_KEY,
+      label: this.translationSlimmer.t('URL'),
+      defaultProtocol: normalizedConfigDefaultProtocol || undefined,
+    };
+  }
+  /**
+   * Normalizes a supported link type while preserving its key.
+   *
+   * @param {VegaRTELinkType} item - Raw configured link type.
+   * @param {string} key - Normalized link type key.
+   * @param {string} configDefaultProtocol - Default protocol from config.
+   * @returns {VegaRTELinkType} The normalized link type descriptor.
+   */
+  normalizeSupportedLinkType(item, key, configDefaultProtocol) {
+    var _a, _b;
+    const normalizedItemDefaultProtocol = (item.defaultProtocol || '').trim();
+    const normalizedConfigDefaultProtocol = (configDefaultProtocol || '').trim();
+    const handler = this.linkTypeHandlers.get(key);
+    const fallbackDefaultProtocol = (_a = handler === null || handler === void 0 ? void 0 : handler.defaultFallbackProtocol) !== null && _a !== void 0 ? _a : (normalizedConfigDefaultProtocol || undefined);
+    return Object.assign(Object.assign({}, item), { key, label: ((_b = item.label) === null || _b === void 0 ? void 0 : _b.trim()) || this.getDefaultLinkTypeLabel(key), defaultProtocol: normalizedItemDefaultProtocol || fallbackDefaultProtocol });
+  }
+  /**
+   * Returns the translated default label for a link type key.
+   *
+   * @param {string} key - Link type key.
+   * @returns {string} The translated label for the link type.
+   */
+  getDefaultLinkTypeLabel(key) {
+    return key === RTE_EMAIL_LINK_TYPE_KEY
+      ? this.translationSlimmer.t('Email')
+      : this.translationSlimmer.t('URL');
+  }
+}
+LinkTypeConfigController.SUPPORTED_LINK_TYPE_KEYS = new Set(RTE_SUPPORTED_LINK_TYPE_KEYS);
+__decorate([
+  MapToComponentField()
+], LinkTypeConfigController.prototype, "host", void 0);
+__decorate([
+  MapToComponentField()
+], LinkTypeConfigController.prototype, "translationSlimmer", void 0);