typo3-typescript-sources 14.3.7 → 14.3.8

package/form/backend/form-editor/modals-component.ts

@@ -54,6 +54,13 @@ const defaultConfiguration: Partial<HelperConfiguration> = {
     rowItem: 'rowItem',
     rowLink: 'rowLink',
     rowsContainer: 'rowsContainer',
+    elementIdentifier: 'elementIdentifier',
+    elementType: 'elementType',
+    validationErrors: 'validationErrors',
+    validationErrorGroup: 'validationErrorGroup',
+    validationErrorGroupLabel: 'validationErrorGroupLabel',
+    validationErrorGroupItems: 'validationErrorGroupItems',
+    validationError: 'validationError',
     templateInsertElements: 'Modal-InsertElements',
     templateInsertPages: 'Modal-InsertPages',
     templateValidationErrors: 'Modal-ValidationErrors'
@@ -206,7 +213,7 @@ function _validationErrorsModalSetup(
   modalContent: DocumentFragment,
   validationResults: ValidationResultsRecursive
 ): void {
-  let formElement, newRowItem;
+  let formElement: FormElement, newRowItem: HTMLElement | null;
 
   assert(
     Array.isArray(validationResults),
@@ -235,13 +242,70 @@ function _validationErrorsModalSetup(
       formElement = getFormEditorApp()
         .getFormElementByIdentifierPath(validationResults[i].formElementIdentifierPath);
       newRowItem = rowItemTemplate?.cloneNode(true) as HTMLElement | null;
-      const rowLink = newRowItem?.querySelector(getHelper().getDomElementDataIdentifierSelector('rowLink'));
-      if (rowLink) {
+      if (newRowItem) {
+        const rowLink = newRowItem;
         rowLink.setAttribute(
           getHelper().getDomElementDataAttribute('elementIdentifier'),
           validationResults[i].formElementIdentifierPath
         );
-        rowLink.replaceChildren(_buildTitleByFormElement(formElement));
+        const rowLinkTitle = rowLink.querySelector('.form-editor-validation-error-title');
+        rowLinkTitle?.replaceChildren(_buildTitleByFormElement(formElement));
+        rowLink.querySelector(
+          getHelper().getDomElementDataIdentifierSelector('elementIdentifier')
+        )?.replaceChildren(document.createTextNode(formElement.get('identifier')));
+        rowLink.querySelector(
+          getHelper().getDomElementDataIdentifierSelector('elementType')
+        )?.replaceChildren(document.createTextNode(
+          getFormElementDefinition(formElement, 'label') || formElement.get('type')
+        ));
+        const validationErrors = rowLink.querySelector(
+          getHelper().getDomElementDataIdentifierSelector('validationErrors')
+        );
+        const validationErrorGroupTemplate = validationErrors?.querySelector(
+          getHelper().getDomElementDataIdentifierSelector('validationErrorGroup')
+        );
+        const validationErrorTemplate = validationErrors?.querySelector(
+          getHelper().getDomElementDataIdentifierSelector('validationError')
+        );
+        validationErrors?.replaceChildren();
+        const validationErrorGroups = new Map<string, HTMLElement>();
+        validationResults[i].validationResults.forEach((propertyValidationResult) => {
+          const propertyLabel = _getPropertyLabelByPath(formElement, propertyValidationResult.propertyPath);
+          const finisherIndex = _getFinisherIndexByPropertyPath(propertyValidationResult.propertyPath);
+          const validatorIdentifier = _getValidatorIdentifierByPropertyPath(formElement, propertyValidationResult.propertyPath);
+          const groupLabel = finisherIndex
+            ? _getFinisherLabelByIdentifier(formElement, finisherIndex)
+            : validatorIdentifier;
+          const groupKey = finisherIndex
+            ? `finisher-${finisherIndex}`
+            : `validator-${validatorIdentifier}`;
+          const validationMessage = propertyValidationResult.validationResults.join(' ');
+          if (groupLabel && validationErrorGroupTemplate) {
+            let validationErrorGroup = validationErrorGroups.get(groupKey);
+            if (!validationErrorGroup) {
+              validationErrorGroup = validationErrorGroupTemplate.cloneNode(true) as HTMLElement;
+              validationErrorGroup.querySelector(
+                getHelper().getDomElementDataIdentifierSelector('validationErrorGroupLabel')
+              )?.replaceChildren(document.createTextNode(groupLabel));
+              validationErrorGroup.querySelector(
+                getHelper().getDomElementDataIdentifierSelector('validationErrorGroupItems')
+              )?.replaceChildren();
+              validationErrorGroups.set(groupKey, validationErrorGroup);
+              validationErrors?.append(validationErrorGroup);
+            }
+            const validationError = validationErrorTemplate?.cloneNode() as HTMLElement | undefined;
+            validationError?.replaceChildren(document.createTextNode(
+              propertyLabel ? `${propertyLabel}: ${validationMessage}` : validationMessage
+            ));
+            validationErrorGroup.querySelector(
+              getHelper().getDomElementDataIdentifierSelector('validationErrorGroupItems')
+            )?.append(validationError);
+          } else {
+            const validationError = validationErrorTemplate?.cloneNode() as HTMLElement | undefined;
+            validationError?.replaceChildren(document.createTextNode(propertyLabel ? `${propertyLabel}: ${validationMessage}` : validationMessage));
+            validationErrors?.append(validationError);
+          }
+        });
       }
       const rowsContainer = modalContent.querySelector(getHelper().getDomElementDataIdentifierSelector('rowsContainer'));
       if (rowsContainer && newRowItem) {
@@ -251,7 +315,8 @@ function _validationErrorsModalSetup(
   }
 
   modalContent.querySelectorAll<HTMLAnchorElement>('a').forEach((a) => {
-    a.addEventListener('click', function() {
+    a.addEventListener('click', function(event: MouseEvent) {
+      event.preventDefault();
       getPublisherSubscriber().publish('view/modal/validationErrors/element/clicked', [
         a.getAttribute(getHelper().getDomElementDataAttribute('elementIdentifier'))
       ]);
@@ -272,6 +337,50 @@ function _buildTitleByFormElement(formElement: FormElement): HTMLElement {
   return span;
 }
 
+function _getPropertyLabelByPath(formElement: FormElement, propertyPath: string): string {
+  return _getEditorConfigurationByPropertyPath(formElement, propertyPath)?.label || '';
+}
+
+function _getValidatorIdentifierByPropertyPath(formElement: FormElement, propertyPath: string): string {
+  const editorConfiguration = _getEditorConfigurationByPropertyPath(formElement, propertyPath);
+  const validatorIdentifier = editorConfiguration?.propertyValidators?.find((identifier) => identifier !== 'NotEmpty');
+  return validatorIdentifier || '';
+}
+
+function _getEditorConfigurationByPropertyPath(
+  formElement: FormElement,
+  propertyPath: string
+): FormElementDefinition['editors'][number] | undefined {
+  const formElementDefinition = getFormElementDefinition(formElement, undefined) as FormElementDefinition;
+  const editors = [
+    ...(formElementDefinition.editors || []),
+    ...Object.values(formElementDefinition.propertyCollections || {}).flatMap((collection) =>
+      collection.flatMap((collectionElement) => collectionElement.editors || [])
+    )
+  ];
+  return editors.find((editorConfiguration) =>
+    editorConfiguration.propertyPath === propertyPath
+    || propertyPath.endsWith(`.${editorConfiguration.propertyPath}`)
+  );
+}
+
+function _getFinisherIndexByPropertyPath(propertyPath: string): string {
+  const match = propertyPath.match(/^finishers\.(\d+)\./);
+  if (!match) {
+    return '';
+  }
+  return match[1];
+}
+
+function _getFinisherLabelByIdentifier(formElement: FormElement, finisherIndex: string): string {
+  const finishers = formElement.get('finishers') as Array<{ identifier: string }> | undefined;
+  const finisherIdentifier = finishers?.[Number(finisherIndex)]?.identifier;
+  if (!finisherIdentifier) {
+    return '';
+  }
+  return getFormEditorApp().getFormEditorDefinition('finishers', finisherIdentifier)?.label || '';
+}
+
 /* *************************************************************
  * Public Methods
  * ************************************************************/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typo3-typescript-sources",
-  "version": "14.3.7",
+  "version": "14.3.8",
   "description": "TYPO3 Core TypeScript Sources - Extracted from TYPO3/typo3 repository",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,7 +28,7 @@
   },
   "typo3": {
     "sourceRepository": "https://github.com/TYPO3/typo3",
-    "sourceTag": "v14.3.7",
+    "sourceTag": "v14.3.8",
     "sourcePath": "Build/Sources/TypeScript"
   }
 }

package/rte-ckeditor/legacy/ckeditor5-bundle.ts

@@ -12,6 +12,5 @@ export * as Widget from '@ckeditor/ckeditor5-widget';
 
 // single or prefixed exports
 export { WordCount } from '@ckeditor/ckeditor5-word-count';
-export { LinkUtils } from '@ckeditor/ckeditor5-link';
 
 console.warn('The module "@typo3/ckeditor5-bundle.js" has been marked as deprecated. Please use "@ckeditor/ckeditor5-*" modules directly.');

package/rte-ckeditor/plugin/typo3-link.ts

@@ -5,11 +5,9 @@ import * as Typing from '@ckeditor/ckeditor5-typing';
 import * as Widget from '@ckeditor/ckeditor5-widget';
 import * as Utils from '@ckeditor/ckeditor5-utils';
 import * as Link from '@ckeditor/ckeditor5-link';
-import { LinkUtils } from '@ckeditor/ckeditor5-link';
 import { default as modalObject, type ModalElement } from '@typo3/backend/modal';
 import type { ViewAttributeElement, ViewElement, ModelSchema, ModelWriter } from '@ckeditor/ckeditor5-engine';
-import type { GeneralHtmlSupport, DataFilter } from '@ckeditor/ckeditor5-html-support';
-import type { GHSViewAttributes } from '@ckeditor/ckeditor5-html-support/src/utils';
+import type { GeneralHtmlSupport, DataFilter, GHSViewAttributes } from '@ckeditor/ckeditor5-html-support';
 import { IconLink, IconPencil, IconUnlink } from '@ckeditor/ckeditor5-icons';
 
 export const LINK_ALLOWED_ATTRIBUTES = ['href', 'title', 'class', 'target', 'rel', 'download'];
@@ -54,7 +52,7 @@ export class Typo3LinkCommand extends Core.Command {
 
     // A check for any integration that allows linking elements (e.g. `LinkImage`).
     // Currently, the selection reads attributes from text nodes only. See #7429 and #7465.
-    const sourceSelection = LinkUtils.isLinkableElement(selectedElement, model.schema) ? selectedElement : selection;
+    const sourceSelection = Link.isLinkableElement(selectedElement, model.schema) ? selectedElement : selection;
     if (sourceSelection === selectedElement) {
       this.value = selectedElement.getAttribute('linkHref') as string;
       this.isEnabled = model.schema.checkAttribute(selectedElement, 'linkHref');
@@ -227,7 +225,7 @@ export class Typo3UnlinkCommand extends Core.Command {
     const selection = model.document.selection;
     const selectedElement = selection.getSelectedElement();
 
-    if (LinkUtils.isLinkableElement(selectedElement, model.schema)) {
+    if (Link.isLinkableElement(selectedElement, model.schema)) {
       this.isEnabled = model.schema.checkAttribute(selectedElement, 'linkHref');
     } else {
       this.isEnabled = model.schema.checkAttributeInSelection(selection, 'linkHref');
@@ -457,7 +455,7 @@ export class Typo3LinkUI extends Core.Plugin {
     const t = editor.t;
 
     // Handle the `Ctrl+K` keystroke and show the panel.
-    editor.keystrokes.set(LinkUtils.LINK_KEYSTROKE, (keyEvtData, cancel) => {
+    editor.keystrokes.set(Link._LINK_KEYSTROKE, (keyEvtData, cancel) => {
       // Prevent focusing the search bar in FF, Chrome and Edge. See https://github.com/ckeditor/ckeditor5/issues/4811.
       cancel();
       if (linkCommand.isEnabled) {
@@ -471,7 +469,7 @@ export class Typo3LinkUI extends Core.Plugin {
       linkButton.isEnabled = true;
       linkButton.label = t('Link');
       linkButton.icon = IconLink;
-      linkButton.keystroke = LinkUtils.LINK_KEYSTROKE;
+      linkButton.keystroke = Link._LINK_KEYSTROKE;
       linkButton.tooltip = true;
       linkButton.isToggleable = true;
       linkButton.bind('isEnabled').to(linkCommand, 'isEnabled');
@@ -486,7 +484,7 @@ export class Typo3LinkUI extends Core.Plugin {
       const linkCommand = editor.commands.get('link');
       button.bind('isEnabled').to(linkCommand, 'value', href => !!href);
       button.bind('href').to(linkCommand, 'value', href => {
-        return href && LinkUtils.ensureSafeUrl(href, allowedProtocols);
+        return href && Link._ensureSafeLinkUrl(href, allowedProtocols);
       });
 
       button.icon = undefined;
@@ -753,7 +751,7 @@ export class Typo3LinkUI extends Core.Plugin {
   }
 
   private findLinkElementAncestor(position: any) {
-    return position.getAncestors().find((ancestor: any) => LinkUtils.isLinkElement(ancestor));
+    return position.getAncestors().find((ancestor: any) => Link.isLinkElement(ancestor));
   }
 
   /**

package/rte-ckeditor/rte-link-browser.ts

@@ -16,7 +16,7 @@ import Modal from '@typo3/backend/modal';
 import RegularEvent from '@typo3/core/event/regular-event';
 import { type Typo3LinkDict, LINK_ALLOWED_ATTRIBUTES, addLinkPrefix } from '@typo3/rte-ckeditor/plugin/typo3-link';
 import type * as Core from '@ckeditor/ckeditor5-core';
-import type { ModelPosition } from '@ckeditor/ckeditor5-engine/src/model/position';
+import type { ModelPosition } from '@ckeditor/ckeditor5-engine';
 import '@typo3/backend/element/combobox-element';
 
 /**

package/scheduler/scheduler-add-group.ts

@@ -37,7 +37,7 @@ class SchedulerAddGroups {
       element.addEventListener('click', (button: MouseEvent) => {
         button.preventDefault();
         const content: TemplateResult = html`
-          <form name="scheduler-create-group" @submit=${this.createGroup}>
+          <form id="scheduler-create-group" name="scheduler-create-group" @submit=${this.createGroup}>
             <label class="form-label" for="actionCreateGroup">Group name</label>
             <input class="form-control" id="actionCreateGroup" required="" name="action[createGroup]" autofocus type="text">
             <div class="form-text mt-3">
@@ -46,7 +46,7 @@ class SchedulerAddGroups {
           </form>
         `;
 
-        const modal = Modal.advanced({
+        Modal.advanced({
           content: content,
           title: labels.get('function.group.add'),
           size: Modal.sizes.small,
@@ -57,21 +57,13 @@ class SchedulerAddGroups {
               btnClass: 'btn-default',
               name: 'cancel'
             },{
-              trigger: (): void => {
-                const form: HTMLFormElement = Modal.currentModal.querySelector('form[name="scheduler-create-group"]');
-                form.requestSubmit();
-              },
               text: labels.get('button.group.modalOk'),
               btnClass: 'btn-primary',
-              name: 'ok'
+              name: 'ok',
+              form: 'scheduler-create-group'
             }
           ]
         });
-
-        modal.addEventListener('typo3-modal-shown', (): void => {
-          const input: HTMLInputElement = Modal.currentModal.querySelector('input[name="action[createGroup]"]');
-          input.focus();
-        });
       });
     }
   }

package/workspaces/preview.ts

@@ -30,6 +30,7 @@ enum Identifiers {
   workspaceView = '.t3js-workspace-view-workspace',
   sendToStageAction = '[data-action="send-to-stage"]',
   discardAction = '[data-action="discard"]',
+  publishAction = '[data-action="publish"]',
   stageButtonsContainer = '.t3js-stage-buttons',
   previewModeContainer = '.t3js-preview-mode',
   activePreviewMode = '.t3js-active-preview-mode',
@@ -78,6 +79,7 @@ class Preview extends Workspaces {
       this.resizeViews();
     }, 50).bindTo(window);
     new RegularEvent('click', this.renderDiscardWindow.bind(this)).delegateTo(document, Identifiers.discardAction);
+    new RegularEvent('click', this.renderPublishWindow.bind(this)).delegateTo(document, Identifiers.publishAction);
     new RegularEvent('click', this.renderSendPageToStageWindow.bind(this)).delegateTo(document, Identifiers.sendToStageAction);
     new RegularEvent('click', () => {
       window.top.document.querySelectorAll('.t3js-workspace-recipient:not([disabled])').forEach((element: HTMLInputElement) => {
@@ -166,6 +168,43 @@ class Preview extends Workspaces {
     });
   }
 
+  private renderPublishWindow(): void {
+    const modal = Modal.confirm(
+      labels.get('window.publishAll.title'),
+      labels.get('window.publishAll.message'),
+      SeverityEnum.warning,
+      [
+        {
+          text: labels.get('cancel'),
+          active: true,
+          btnClass: 'btn-default',
+          name: 'cancel',
+          trigger: (): void => {
+            modal.hideModal();
+          },
+        },
+        {
+          text: labels.get('ok'),
+          btnClass: 'btn-warning',
+          name: 'ok',
+        },
+      ],
+    );
+    modal.addEventListener('button.clicked', (e: Event): void => {
+      if ((e.target as HTMLButtonElement).name === 'ok') {
+        this.sendRemoteRequest([
+          this.generateRemotePayloadBody('publishPageDirectly', [TYPO3.settings.Workspaces.id]),
+          this.generateRemotePayloadBody('updateStageChangeButtons', [TYPO3.settings.Workspaces.id]),
+        ], Identifiers.topbar).then(async (response: AjaxResponse): Promise<void> => {
+          modal.hideModal();
+          this.renderStageButtons((await response.resolve())[1].result);
+          // Reloading live view IFRAME
+          this.elements.workspaceView.setAttribute('src', this.elements.workspaceView.getAttribute('src'));
+        });
+      }
+    });
+  }
+
   /**
    * Renders the "send page to stage" window
    */

package/workspaces/renderable/record-table.ts

@@ -32,6 +32,15 @@ export type AdditionalColumnValue = {
   url?: string
 };
 
+export type ActionData = {
+  group?: string,
+  enabled?: boolean,
+  visible?: boolean,
+  icon?: string,
+  title?: string,
+  url?: string
+};
+
 export type RecordData = {
   table: string,
   id: string,
@@ -76,7 +85,8 @@ export type RecordData = {
     status: string,
     messages: string
   },
-  additional?: Record<string, AdditionalColumnValue>
+  additional?: Record<string, AdditionalColumnValue>,
+  actions?: Record<string, ActionData>
 };
 
 @customElement('typo3-workspaces-record-table')
@@ -280,10 +290,7 @@ export class RecordTableElement extends LitElement {
         ` : nothing}</td>
         <td>${data.label_Stage}</td>
         ${Object.keys(this.additionalColumns).map((identifier: string) => this.renderAdditionalColumn(data, identifier))}
-        <td class="col-control nowrap">
-          <div class="btn-group">${this.renderElementActions(data)}</div>
-          <div class="btn-group">${this.renderVersioningActions(data)}</div>
-        </td>
+        <td class="col-control nowrap">${this.renderActions(data)}</td>
       </tr>
     `;
   }
@@ -308,42 +315,94 @@ export class RecordTableElement extends LitElement {
     `;
   }
 
+  /**
+   * The action buttons of a row, rendered as one button group per group declared by the server.
+   * Which actions exist is decided there, the module only knows how to present its own ones.
+   */
+  protected renderActions(data: RecordData): TemplateResult[] {
+    const groups = new Map<string, TemplateResult[]>();
+
+    for (const [ identifier, action ] of Object.entries(data.actions ?? {})) {
+      if (action.visible === false) {
+        continue;
+      }
+      const group = action.group ?? 'custom';
+      if (!groups.has(group)) {
+        groups.set(group, []);
+      }
+      groups.get(group).push(this.renderAction(identifier, action, data));
+    }
+
+    return Array.from(groups.values()).map((actions: TemplateResult[]) => html`
+      <div class="btn-group">${actions}</div>
+    `);
+  }
+
+  protected renderAction(identifier: string, action: ActionData, data: RecordData): TemplateResult {
+    const enabled = action.enabled !== false;
+
+    if (identifier === 'qrcode') {
+      return this.getQrCodeAction(data, enabled);
+    }
+
+    const defaults = this.getActionDefaults(identifier, data, enabled);
+    const attributes: Record<string, string> = { ...defaults.attributes };
+    const title = action.title || defaults.title;
+    if (title !== '') {
+      attributes.title = title;
+    }
+    const icon = action.icon || defaults.icon;
+
+    if (action.url && enabled) {
+      return html`
+        <a class="btn btn-default" href=${action.url} title=${ifDefined(attributes.title)}>
+          <typo3-backend-icon identifier=${IconHelper.getIconIdentifier(icon || 'empty-empty')} size="small"></typo3-backend-icon>
+        </a>
+      `;
+    }
+
+    return this.getAction(enabled, identifier, icon, attributes);
+  }
+
   protected renderIndent(level: number) {
     return html`<span class="indent indent-inline-block" style="--indent-level: ${level}"></span>`;
   }
 
-  private renderElementActions(data: RecordData): TemplateResult[] {
-    return [
-      this.getAction(
-        (data.allowedAction_view && data.previewUrl !== ''),
-        'preview',
-        'actions-version-workspace-preview',
-        {
-          'title': labels.get('tooltip.viewElementAction')
-        }
-      ),
-      this.getQrCodeAction(data),
-      this.getAction(
-        data.allowedAction_edit && data.state_Workspace !== 'deleted',
-        'open',
-        'actions-open',
-        {
-          'title': labels.get('tooltip.editElementAction')
-        }
-      ),
-      this.getAction(
-        data.allowedAction_versionPageOpen,
-        'version',
-        'actions-version-page-open',
-        {
-          'title': labels.get('tooltip.openPage')
-        }
-      )
-    ];
+  /**
+   * Icon, title and attributes of the actions the module handles itself. Actions of third party
+   * extensions are unknown here and are presented with what their payload provides.
+   */
+  private getActionDefaults(identifier: string, data: RecordData, enabled: boolean): { icon: string, title: string, attributes: Record<string, string> } {
+    switch (identifier) {
+      case 'preview':
+        return { icon: 'actions-version-workspace-preview', title: labels.get('tooltip.viewElementAction'), attributes: {} };
+      case 'open':
+        return { icon: 'actions-open', title: labels.get('tooltip.editElementAction'), attributes: {} };
+      case 'version':
+        return { icon: 'actions-version-page-open', title: labels.get('tooltip.openPage'), attributes: {} };
+      case 'expand':
+        return {
+          icon: data.expanded ? 'actions-caret-down' : 'actions-caret-right',
+          title: labels.get('tooltip.expand'),
+          attributes: {
+            'data-bs-target': '[data-collection="' + data.Workspaces_CollectionCurrent + '"]',
+            'aria-expanded': !enabled || data.expanded ? 'true' : 'false',
+            'data-bs-toggle': 'collapse',
+          }
+        };
+      case 'changes':
+        return { icon: 'actions-document-info', title: labels.get('tooltip.showChanges'), attributes: {} };
+      case 'publish':
+        return { icon: 'actions-version-swap-version', title: labels.get('tooltip.publish'), attributes: {} };
+      case 'remove':
+        return { icon: 'actions-delete', title: labels.get('tooltip.discardVersion'), attributes: {} };
+      default:
+        return { icon: '', title: '', attributes: {} };
+    }
   }
 
-  private getQrCodeAction(data: RecordData): TemplateResult {
-    if (!data.previewUrl) {
+  private getQrCodeAction(data: RecordData, enabled: boolean): TemplateResult {
+    if (!enabled || !data.previewUrl) {
       return html`
         <button type="button" class="btn btn-default" disabled>
           <typo3-backend-icon identifier="empty-empty" size="small"></typo3-backend-icon>
@@ -361,48 +420,6 @@ export class RecordTableElement extends LitElement {
     `;
   }
 
-  private renderVersioningActions(data: RecordData): TemplateResult[] {
-    const hasSubitems = data.Workspaces_CollectionChildren > 0 && data.Workspaces_CollectionCurrent !== '';
-
-    return [
-      this.getAction(
-        hasSubitems,
-        'expand',
-        (data.expanded ? 'actions-caret-down' : 'actions-caret-right'),
-        {
-          'title': labels.get('tooltip.expand'),
-          'data-bs-target': '[data-collection="' + data.Workspaces_CollectionCurrent + '"]',
-          'aria-expanded': !hasSubitems || data.expanded ? 'true' : 'false',
-          'data-bs-toggle': 'collapse',
-        }
-      ),
-      this.getAction(
-        data.hasChanges,
-        'changes',
-        'actions-document-info',
-        {
-          'title': labels.get('tooltip.showChanges')
-        }
-      ),
-      this.getAction(
-        data.allowedAction_publish && data.Workspaces_CollectionParent === '',
-        'publish',
-        'actions-version-swap-version',
-        {
-          'title': labels.get('tooltip.publish')
-        }
-      ),
-      this.getAction(
-        data.allowedAction_delete,
-        'remove',
-        'actions-delete',
-        {
-          'title': labels.get('tooltip.discardVersion')
-        }
-      )
-    ];
-  }
-
   /**
    * Renders the action button based on the user's permission.
    *