typo3-typescript-sources 14.3.5 → 14.3.7

package/.last-synced-tag

@@ -1 +1 @@
-v14.3.5
+v14.3.7

package/README-TYPO3.md

@@ -75,7 +75,7 @@ with each other and with the public. Several TYPO3 teams use Slack as a
 way to communicate internally and most channels are a welcome place for
 you to join and get yourself involved.
 
-* Register: https://my.typo3.org/about-mytypo3org/slack
+* Register: https://typo3.community/meet/slack/
 * Slack: https://typo3.slack.com/
 
 ### Exchange information, ask questions, get help

package/README.md

@@ -16,7 +16,7 @@ npm install typo3-typescript-sources
 
 - **Original Repository:** [TYPO3/typo3](https://github.com/TYPO3/typo3)
 - **Source Path:** `Build/Sources/TypeScript/`
-- **Current TYPO3 Version:** `v14.3.5`
+- **Current TYPO3 Version:** `v14.3.7`
 
 ## 🌿 Branches
 

package/backend/element/contextual-record-edit-trigger.ts

@@ -27,11 +27,17 @@ import labels from '~labels/backend.alt_doc';
  *
  * `url` attribute points to the contextual edit route
  * `edit-url` points to the full FormEngine route.
+ * `context` identifies what's being edited, used to persist the sheet's
+ * width independently per context. This might be just the database table
+ * (e.g. "pages" and "sys_category" are resized independently), but callers
+ * may pass a more specific value later, e.g. "tt_content.textmedia" vs.
+ * "tt_content.header", once per-CType widths are needed.
  *
  * @example
  * <typo3-backend-contextual-record-edit-trigger
  *   url="/typo3/record/edit/contextual?..."
- *   edit-url="/typo3/record/edit?...">
+ *   edit-url="/typo3/record/edit?..."
+ *   context="pages">
  *   Edit record
  * </typo3-backend-contextual-record-edit-trigger>
  */
@@ -39,6 +45,7 @@ import labels from '~labels/backend.alt_doc';
 export class ContextualRecordEditTriggerElement extends PseudoButtonLitElement {
   @property({ type: String }) url: string;
   @property({ type: String, attribute: 'edit-url' }) editUrl: string;
+  @property({ type: String }) context: string = '';
 
   protected override async buttonActivated(): Promise<void> {
     if (Persistent.isset('contextualRecordEdit') && Persistent.get('contextualRecordEdit') == 0) {
@@ -54,6 +61,7 @@ export class ContextualRecordEditTriggerElement extends PseudoButtonLitElement {
       size: Sizes.expand,
       position: Positions.sheet,
       hideHeader: true,
+      resizeIdentifier: `contextualEdit${this.context ? `.${this.context}` : ''}`,
     });
     this.setupMessageHandling(modal);
   }

package/backend/form-engine/element/extra/select-box-filter.ts

@@ -12,6 +12,7 @@
  */
 
 import RegularEvent from '@typo3/core/event/regular-event';
+import TextNormalizer from '@typo3/core/utility/text-normalizer';
 
 enum Selectors {
   fieldContainerSelector = '.t3js-formengine-field-group',
@@ -25,6 +26,7 @@ enum Selectors {
 class SelectBoxFilter {
   private readonly selectElement: HTMLSelectElement = null;
   private availableOptions: NodeListOf<HTMLOptionElement> = null;
+  private foldedLabels: string[] = null;
 
   constructor(selectElement: HTMLSelectElement) {
     this.selectElement = selectElement;
@@ -73,14 +75,15 @@ class SelectBoxFilter {
   private filter(filterText: string): void {
     if (this.availableOptions === null) {
       this.availableOptions = this.selectElement.querySelectorAll('option');
+      this.foldedLabels = Array.from(this.availableOptions, (option: HTMLOptionElement): string =>
+        TextNormalizer.foldCaseAndDiacritics(TextNormalizer.normalizeInvisibleCharacters(option.textContent)));
     }
 
-    // Escape filter text to prevent RegExp() exceptions
-    const escapedFilterText = filterText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // A plain substring match, no RegExp involved, therefore nothing to escape either
+    const foldedFilterText = TextNormalizer.foldCaseAndDiacritics(TextNormalizer.normalizeInvisibleCharacters(filterText));
 
-    const matchFilter = new RegExp(escapedFilterText, 'i');
-    this.availableOptions.forEach((option: HTMLOptionElement): void => {
-      option.hidden = filterText.length > 0 && option.textContent.match(matchFilter) === null;
+    this.availableOptions.forEach((option: HTMLOptionElement, index: number): void => {
+      option.hidden = filterText.length > 0 && !this.foldedLabels[index].includes(foldedFilterText);
       SelectBoxFilter.toggleOptGroup(option);
     });
   }

package/backend/form-engine/element/select-tree.ts

@@ -14,6 +14,7 @@
 import { html, type TemplateResult } from 'lit';
 import { Tree, type TreeSettings } from '@typo3/backend/tree/tree';
 import { customElement, state } from 'lit/decorators.js';
+import TextNormalizer from '@typo3/core/utility/text-normalizer';
 import type { TreeNodeInterface } from '@typo3/backend/tree/tree-node';
 
 interface SelectTreeSettings extends TreeSettings {
@@ -48,6 +49,18 @@ export class SelectTree extends Tree
     this.addEventListener('typo3:tree:nodes-prepared', this.prepareLoadedNodes);
   }
 
+  /**
+   * Fold both sides of the comparison the filter performs, so that a node is
+   * found whether or not the diacritics of its name are typed.
+   *
+   * The names are folded on every keystroke rather than kept beside the node,
+   * because writing to a node triggers a re-render and the nodes are replaced
+   * whenever a part of the tree is loaded.
+   */
+  private static fold(value: string): string {
+    return TextNormalizer.foldCaseAndDiacritics(TextNormalizer.normalizeInvisibleCharacters(value));
+  }
+
   /**
    * Expand all nodes and refresh view
    */
@@ -89,7 +102,8 @@ export class SelectTree extends Tree
       this.nodes[0].__expanded = false;
     }
     const firstNode = this.nodes[0];
-    const regex = new RegExp(searchTerm, 'i');
+    // A plain substring match, no RegExp involved, therefore nothing to escape either
+    const foldedSearchTerm = SelectTree.fold(searchTerm ?? '');
 
     this.nodes.forEach((node: any) => {
       // skip the root node in searches
@@ -100,7 +114,7 @@ export class SelectTree extends Tree
       node.__expanded = false;
       node.__hidden = true;
 
-      if (regex.test(node.name)) {
+      if (SelectTree.fold(node.name).includes(foldedSearchTerm)) {
         results.push(node);
       }
     });

package/backend/form-engine/element/slug-element.ts

@@ -88,7 +88,7 @@ class SlugElement {
   }
 
   private registerEvents(): void {
-    const fieldsToListenOnList = Object.values(this.getAvailableFieldsForProposalGeneration()).map((field: HTMLElement) => `[id="${field.id}"]`);
+    const fieldsToListenOnList = Object.values(this.getAvailableFieldsForProposalGeneration()).map((field: HTMLElement) => field.dataset.slugSelector);
     const recreateButton: HTMLButtonElement = this.fullElement.querySelector(Selectors.recreateButton);
 
     // Listen on 'listenerFieldNames' for new pages. This is typically the 'title' field
@@ -217,12 +217,20 @@ class SlugElement {
   private getAvailableFieldsForProposalGeneration(): { [key: string]: HTMLElement } {
     const availableFields: { [key: string]: HTMLElement } = {};
     for (const [fieldName, selector] of Object.entries(this.fieldsToListenOn)) {
-      let field = document.querySelector('[data-formengine-input-name="' + selector + '"]') as HTMLElement;
-      if (field === null) {
+      const selectorCandidates = [
+        '[data-formengine-input-name="' + selector + '"]',
         // Also check for fields, which do not point to a hidden input field (e.g. "input type=hidden", readOnly, or select fields)
-        field = document.querySelector('[name="' + selector + '"]') as HTMLElement;
-      }
+        '[name="' + selector + '"]'
+      ];
+      let field: HTMLElement;
+      let usedSelector = '';
+      selectorCandidates.some((testSelector: string) => {
+        field = document.querySelector(testSelector) as HTMLElement;
+        usedSelector = testSelector;
+        return field !== null;
+      });
       if (field !== null) {
+        field.dataset.slugSelector = usedSelector;
         availableFields[fieldName] = field;
       }
     }

package/backend/form-engine/field-control/add-record.ts

@@ -33,7 +33,33 @@ class AddRecord {
   private readonly registerClickHandler = (e: Event): void => {
     e.preventDefault();
 
-    FormEngine.preventFollowLinkIfNotSaved(this.controlElement.getAttribute('href'));
+    const href = this.controlElement.getAttribute('href');
+    const url = new URL(href, window.location.origin);
+    const ownerUid = url.searchParams.get('P[uid]') || '';
+    if (ownerUid.startsWith('NEW')) {
+      // The record this field belongs to is itself still unsaved:
+      // Wizard/AddController can only link a newly created record back into
+      // an already-persisted uid, so a plain "leave without saving?" prompt
+      // would both discard this record AND silently fail to link anything.
+      // Deliberately not passing along this href's own P[returnUrl] here: for
+      // a field belonging to an inline/IRRE child that was itself added via
+      // AJAX (record_inline_create), that value is whatever URL rendered the
+      // child's markup at ajax-creation time. The ajax endpoint's own URL,
+      // not a real, navigable page. EditDocumentController computes the
+      // correct return-to-this-document URL itself once the save completes.
+      FormEngine.preventFollowAddRecordLinkIfNotSaved({
+        originalUid: ownerUid,
+        ownerTable: url.searchParams.get('P[table]') || '',
+        ownerField: url.searchParams.get('P[field]') || '',
+        table: url.searchParams.get('P[params][table]') || '',
+        pid: url.searchParams.get('P[params][pid]') || '',
+        setValue: url.searchParams.get('P[params][setValue]') || 'append',
+        flexFormPath: url.searchParams.get('P[flexFormPath]') || '',
+      });
+      return;
+    }
+
+    FormEngine.preventFollowLinkIfNotSaved(href);
   };
 }
 

package/backend/form-engine.ts

@@ -62,6 +62,7 @@ const enum FormAction {
   saveAndView = '_savedokview',
   saveAndNew = '_savedoknew',
   duplicate = '_duplicatedoc',
+  saveAndAddRecord = '_savedokaddrecord',
 }
 
 type OnChangeFieldHandlerCallback = (data: object, e: Event) => void;
@@ -134,7 +135,7 @@ export default (function() {
           btnClass: 'btn-' + Severity.getCssClass(Severity.warning),
           name: 'ok',
           trigger: () => {
-            FormEngine.closeModalsRecursive();
+            modal.hideModal();
             saveDocumentWithoutValidation();
           }
         }
@@ -900,6 +901,84 @@ export default (function() {
     }
   };
 
+  /**
+   * Show modal to confirm following a "+ add related record" (fieldControl.addRecord)
+   * link whose OWN record is itself still new/unsaved. Since Wizard/AddController
+   * can only link a newly created record back into an already-persisted uid,
+   * discarding here means abandoning the whole attempt (closing the document,
+   * same as preventExitIfNotSavedCallback) rather than following through to
+   * create an orphaned record that could never be linked back anyway. The
+   * only way to actually continue to the add-record wizard is "save first".
+   *
+   * @param {Object.<string, string>} addRecordParams
+   * @returns {Boolean}
+   */
+  FormEngine.preventFollowAddRecordLinkIfNotSaved = function(addRecordParams: {[key: string]: string}): boolean {
+    const title = backendAltDocLabels.get('label.confirm.add_record_unsaved_parent.title');
+    const content = backendAltDocLabels.get('label.confirm.add_record_unsaved_parent.content');
+    const buttons: Array<{text: string, btnClass: string, name: string, active?: boolean}> = [
+      {
+        text: backendAltDocLabels.get('buttons.confirm.close_without_save.no'),
+        btnClass: 'btn-default',
+        name: 'no'
+      },
+      {
+        text: backendAltDocLabels.get('buttons.confirm.close_without_save.yes'),
+        btnClass: 'btn-default',
+        name: 'yes'
+      }
+    ];
+    if (document.querySelector('.has-error') === null) {
+      buttons.push({
+        text: backendAltDocLabels.get('buttons.confirm.add_record_unsaved_parent.save'),
+        btnClass: 'btn-primary',
+        name: 'save',
+        active: true
+      });
+    }
+
+    const modal = Modal.confirm(title, content, Severity.warning, buttons);
+    modal.addEventListener('button.clicked', function(e: Event) {
+      modal.hideModal();
+      const name = (e.target as HTMLButtonElement).name;
+      if (name === 'yes') {
+        FormEngine.closeDocument();
+      } else if (name === 'save') {
+        FormEngine.saveAndContinueToAddRecord(addRecordParams);
+      }
+    });
+    return false;
+  };
+
+  /**
+   * Saves the current document, then (server-side, once the record this
+   * addRecordParams.originalUid placeholder was saved under is known)
+   * redirects on to Wizard/AddController for the field identified by
+   * addRecordParams, see FormAction::savedokaddrecord() /
+   * EditDocumentController::processData().
+   *
+   * @param {Object.<string, string>} addRecordParams
+   */
+  FormEngine.saveAndContinueToAddRecord = function(addRecordParams: {[key: string]: string}): void {
+    Object.keys(addRecordParams).forEach((key: string): void => {
+      const input = document.createElement('input');
+      input.type = 'hidden';
+      input.name = 'addRecordAfterSave[' + key + ']';
+      input.value = addRecordParams[key];
+      FormEngine.formElement.append(input);
+    });
+    const actionInput = document.createElement('input');
+    actionInput.type = 'hidden';
+    actionInput.name = FormAction.saveAndAddRecord;
+    actionInput.value = '1';
+    FormEngine.formElement.append(actionInput);
+    // Submitted as a regular save on top: "_savedokaddrecord" is only understood by
+    // EditDocumentController, while other hosts of FormEngine forms (site configuration,
+    // constant editor, ...) test "_savedok" literally. Without it, such a form would
+    // neither save nor create anything and silently discard the submitted data.
+    submitFormWithAction(FormAction.save);
+  };
+
   /**
    * Show modal to confirm closing the document without saving
    */

package/backend/layout-module/sticky-language-header.ts

@@ -0,0 +1,186 @@
+/*
+ * This file is part of the TYPO3 CMS project.
+ *
+ * It is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, either version 2
+ * of the License, or any later version.
+ *
+ * For the full copyright and license information, please read the
+ * LICENSE.txt file that was distributed with this source code.
+ *
+ * The TYPO3 project - inspiring people to share!
+ */
+
+import { css, html, LitElement, type TemplateResult } from 'lit';
+import { customElement, query, state } from 'lit/decorators.js';
+import RegularEvent from '@typo3/core/event/regular-event';
+
+/**
+ * Module: @typo3/backend/layout-module/sticky-language-header
+ *
+ * Carries the header information of a language column twice: the default slot
+ * stays in the flow, the "sticky" slot holds a copy that is placed below the
+ * doc header, aligned with its column, for as long as the header itself is
+ * scrolled out of view. Without a "sticky" slot the element is inert.
+ */
+@customElement('typo3-backend-page-layout-sticky-language-header')
+export class PageLayoutStickyLanguageHeader extends LitElement {
+  static override styles = css`
+    /* the global border-box reset does not cross the shadow boundary */
+    :host,
+    *,
+    *::before,
+    *::after {
+      box-sizing: border-box;
+    }
+
+    :host {
+      display: block;
+    }
+
+    .sticky {
+      display: flex;
+      align-items: center;
+      gap: .5rem;
+      position: fixed;
+      z-index: calc(var(--typo3-zindex-header) - 2);
+      padding: .5rem .75rem;
+      white-space: nowrap;
+      overflow: hidden;
+      pointer-events: none;
+      color: var(--typo3-component-color);
+      background-color: var(--typo3-component-bg);
+      border: var(--typo3-component-border-width) solid var(--typo3-component-border-color);
+      border-top: 0;
+      border-radius: 0 0 var(--pagemodule-grid-cell-border-radius) var(--pagemodule-grid-cell-border-radius);
+      box-shadow: var(--typo3-component-box-shadow-flyout);
+      opacity: 0;
+      /*
+       * The doc header is overlapped by a pixel: it ends on a fractional
+       * position, and two boxes meeting there round apart when they are
+       * rasterized, which lets the page show through the seam. Offset via top,
+       * a transform on a fixed element causes repaint artifacts.
+       */
+      top: calc(var(--sticky-top, 0px) - 1px - .5rem);
+      transition: opacity .2s ease-out, top .2s ease-out;
+    }
+
+    .sticky-active {
+      opacity: 1;
+      top: calc(var(--sticky-top, 0px) - 1px);
+    }
+
+    ::slotted([slot="sticky"]) {
+      display: flex;
+      align-items: center;
+      gap: .5rem;
+      min-width: 0;
+    }
+
+    @media (prefers-reduced-motion: reduce) {
+      .sticky {
+        transition: none;
+      }
+    }
+  `;
+
+  // how far the box shadow reaches beyond the border box
+  private static readonly shadowBleed: number = 64;
+
+  @state() protected active: boolean = false;
+
+  @query('.inline') private readonly inline: HTMLElement;
+  @query('.sticky') private readonly sticky: HTMLElement;
+
+  private scrollEvent: RegularEvent | null = null;
+  private resizeEvent: RegularEvent | null = null;
+  private ticking: boolean = false;
+
+  public override connectedCallback(): void {
+    super.connectedCallback();
+    const sticky = this.querySelector(':scope > [slot="sticky"]');
+    if (sticky === null) {
+      return;
+    }
+    // the slot is rendered with [hidden] so it does not flash before the element
+    // is upgraded, and the global reset declares that one !important
+    sticky.removeAttribute('hidden');
+    this.scrollEvent = new RegularEvent('scroll', this.scheduleSync, true);
+    this.scrollEvent.bindTo(document);
+    this.resizeEvent = new RegularEvent('resize', this.scheduleSync);
+    this.resizeEvent.bindTo(window);
+  }
+
+  public override disconnectedCallback(): void {
+    this.scrollEvent?.release();
+    this.resizeEvent?.release();
+    this.scrollEvent = null;
+    this.resizeEvent = null;
+    super.disconnectedCallback();
+  }
+
+  protected override firstUpdated(): void {
+    this.scheduleSync();
+  }
+
+  protected override render(): TemplateResult {
+    return html`
+      <div class="inline"><slot></slot></div>
+      <div class="sticky${this.active ? ' sticky-active' : ''}" aria-hidden="true">
+        <slot name="sticky"></slot>
+      </div>`;
+  }
+
+  private readonly scheduleSync = (): void => {
+    if (this.ticking) {
+      return;
+    }
+    this.ticking = true;
+    requestAnimationFrame((): void => {
+      this.ticking = false;
+      this.sync();
+    });
+  };
+
+  private sync(): void {
+    const container = this.closest('.t3-grid-container');
+    if (container === null || !this.inline || !this.sticky) {
+      return;
+    }
+    // the lower edge of the doc header in viewport coordinates, which is where the
+    // element is placed: whichever of its bars still reaches into the viewport wins,
+    // so it holds for a missing button bar and for a bar that wrapped into two rows
+    const topOffset: number = Math.max(0, ...Array.from(
+      this.ownerDocument.querySelectorAll('.module-docheader'),
+      (bar: Element): number => bar.getBoundingClientRect().bottom,
+    ));
+    const containerRect = container.getBoundingClientRect();
+    const inlineRect = this.inline.getBoundingClientRect();
+    this.active = inlineRect.bottom <= topOffset && containerRect.bottom > topOffset;
+    if (!this.active) {
+      return;
+    }
+    this.sticky.style.setProperty('--sticky-top', topOffset + 'px');
+    this.sticky.style.left = inlineRect.left + 'px';
+    this.sticky.style.width = inlineRect.width + 'px';
+    const cutStart = Math.max(0, containerRect.left - inlineRect.left);
+    const cutEnd = Math.max(0, inlineRect.right - containerRect.right);
+    if (cutStart > 0 || cutEnd > 0) {
+      // clip-path takes the border box as its reference, so the region has to reach
+      // beyond it on every side that is not cut, or the box shadow is clipped away too
+      const bleed = -PageLayoutStickyLanguageHeader.shadowBleed + 'px';
+      const start = cutStart > 0 ? cutStart + 'px' : bleed;
+      const end = cutEnd > 0 ? cutEnd + 'px' : bleed;
+      this.sticky.style.clipPath = `inset(${bleed} ${end} ${bleed} ${start})`;
+    } else {
+      this.sticky.style.clipPath = '';
+    }
+    this.sticky.style.visibility = cutStart < inlineRect.width && cutEnd < inlineRect.width ? '' : 'hidden';
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'typo3-backend-page-layout-sticky-language-header': PageLayoutStickyLanguageHeader;
+  }
+}

package/backend/live-search/element/result/item/item.ts

@@ -27,8 +27,10 @@ export interface ResultItemInterface {
   defaultAction: ResultItemActionInterface;
   icon: Record<string, string>;
   language: ResultItemLanguageInterface | null;
+  thumbnailUrl: string | null;
   itemTitle: string;
   typeLabel: string;
+  properties: Record<string, string>;
   extraData: { [key: string]: any }
 }
 

package/backend/live-search/element/result/result-detail-container.ts

@@ -32,12 +32,25 @@ export class ResultDetailContainer extends LitElement {
       return nothing;
     }
 
+    const propertyEntries = Object.entries(this.resultItem.properties ?? {});
+
     return html`
       <div class="livesearch-detail-preamble">
-        <typo3-backend-icon identifier="${this.resultItem.icon.identifier}" overlay="${this.resultItem.icon.overlay}" size="large"></typo3-backend-icon>
+        ${this.resultItem.thumbnailUrl
+    ? html`<div class="livesearch-detail-preamble-thumbnail"><img src="${this.resultItem.thumbnailUrl}" loading="lazy" alt=""></div>`
+    : html`<typo3-backend-icon identifier="${this.resultItem.icon.identifier}" overlay="${this.resultItem.icon.overlay}" size="large"></typo3-backend-icon>`
+}
         <h3>${this.resultItem.itemTitle}</h3>
         <p class="livesearch-detail-preamble-type">${this.resultItem.typeLabel}</p>
       </div>
+      ${propertyEntries.length > 0 ? html`
+        <dl class="livesearch-detail-properties">
+          ${propertyEntries.map(([label, value]: [string, string]) => html`
+            <dt>${label}</dt>
+            <dd>${value}</dd>
+          `)}
+        </dl>
+      ` : nothing}
       <typo3-backend-live-search-result-item-action-container .resultItem="${this.resultItem}"></typo3-backend-live-search-result-item-action-container>
     `;
   }

package/backend/localization/localization-wizard.ts

@@ -151,6 +151,9 @@ export class LocalizationWizard extends LitElement {
 
   private handleStepSummary(event: StepSummaryEvent) {
     const recordInfo = this.recordInfoTask.value;
+    if (recordInfo === undefined) {
+      return;
+    }
     event.detail.summaryData = [
       {
         label: recordInfo.typeName,

package/backend/localization/steps/handler-selection-step.ts

@@ -45,23 +45,18 @@ export class HandlerSelectionStep implements WizardStepInterface, WizardStepValu
           return [];
         }
 
-        try {
-          const response = await new AjaxRequest(TYPO3.settings.ajaxUrls.wizard_localization_get_handlers)
-            .withQueryArguments({
-              recordType: recordType,
-              recordUid: recordUid,
-              sourceLanguage: sourceLanguage,
-              targetLanguage: targetLanguage,
-              mode: mode,
-            })
-            .get();
-          const handlers: LocalizationHandler[] = await response.resolve();
-
-          return handlers;
-        } catch (error) {
-          console.warn('Failed to fetch handlers:', error);
-          return [];
-        }
+        const response = await new AjaxRequest(TYPO3.settings.ajaxUrls.wizard_localization_get_handlers)
+          .withQueryArguments({
+            recordType: recordType,
+            recordUid: recordUid,
+            sourceLanguage: sourceLanguage,
+            targetLanguage: targetLanguage,
+            mode: mode,
+          })
+          .get();
+        const handlers: LocalizationHandler[] = await response.resolve();
+
+        return handlers;
       },
       args: () => [this.context.recordType, this.context.recordUid, this.context.getStoreData('sourceLanguage'), this.context.getStoreData('targetLanguage'), this.context.getStoreData('localizationMode')],
       autoRun: false

package/backend/localization/steps/mode-step.ts

@@ -46,20 +46,15 @@ export class ModeStep implements WizardStepInterface, WizardStepValueInterface,
           return [];
         }
 
-        try {
-          const response = await new AjaxRequest(TYPO3.settings.ajaxUrls.wizard_localization_get_modes).withQueryArguments({
-            recordType: recordType,
-            recordUid: recordUid,
-            targetLanguage: targetLanguage,
-            sourceLanguage: sourceLanguage,
-          }).get();
-          const modes: LocalizationMode[] = await response.resolve();
-
-          return modes;
-        } catch (error) {
-          console.warn('Failed to fetch localization modes:', error);
-          return [];
-        }
+        const response = await new AjaxRequest(TYPO3.settings.ajaxUrls.wizard_localization_get_modes).withQueryArguments({
+          recordType: recordType,
+          recordUid: recordUid,
+          targetLanguage: targetLanguage,
+          sourceLanguage: sourceLanguage,
+        }).get();
+        const modes: LocalizationMode[] = await response.resolve();
+
+        return modes;
       },
       args: () => [this.context.recordType, this.context.recordUid, this.context.getStoreData('targetLanguage'), this.context.getStoreData('sourceLanguage')],
       autoRun: false

package/backend/localization/steps/source-language-step.ts

@@ -38,19 +38,14 @@ export class SourceLanguageStep implements WizardStepInterface, WizardStepValueI
           return [];
         }
 
-        try {
-          const response = await new AjaxRequest(TYPO3.settings.ajaxUrls.wizard_localization_get_sources).withQueryArguments({
-            recordType: recordType,
-            recordUid: recordUid,
-            targetLanguage: targetLanguageId,
-          }).get();
-          const sourceLanguages: LocalizationLanguageRecord[] = await response.resolve();
-
-          return sourceLanguages;
-        } catch (error) {
-          console.warn('Failed to fetch source languages:', error);
-          return [];
-        }
+        const response = await new AjaxRequest(TYPO3.settings.ajaxUrls.wizard_localization_get_sources).withQueryArguments({
+          recordType: recordType,
+          recordUid: recordUid,
+          targetLanguage: targetLanguageId,
+        }).get();
+        const sourceLanguages: LocalizationLanguageRecord[] = await response.resolve();
+
+        return sourceLanguages;
       },
       args: () => [this.context.recordType, this.context.recordUid, this.context.getStoreData('targetLanguage')],
       autoRun: false