typo3-typescript-sources 13.4.20

package/filelist/file-list.ts

@@ -0,0 +1,396 @@
+/*
+ * 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 { lll } from '@typo3/core/lit-helper';
+import DocumentService from '@typo3/core/document-service';
+import Notification from '@typo3/backend/notification';
+import InfoWindow from '@typo3/backend/info-window';
+import { FileListActionEvent, type FileListActionDetail, FileListActionSelector, FileListActionUtility } from '@typo3/filelist/file-list-actions';
+import NProgress from 'nprogress';
+import Icons from '@typo3/backend/icons';
+import AjaxRequest from '@typo3/core/ajax/ajax-request';
+import type { AjaxResponse } from '@typo3/core/ajax/ajax-response';
+import RegularEvent from '@typo3/core/event/regular-event';
+import { ModuleStateStorage } from '@typo3/backend/storage/module-state-storage';
+import { default as Modal, type ModalElement } from '@typo3/backend/modal';
+import { SeverityEnum } from '@typo3/backend/enum/severity';
+import Severity from '@typo3/backend/severity';
+import { MultiRecordSelectionSelectors } from '@typo3/backend/multi-record-selection';
+import ContextMenu from '@typo3/backend/context-menu';
+import type { ActionConfiguration, ActionEventDetails } from '@typo3/backend/multi-record-selection-action';
+import type { ResourceInterface } from '@typo3/backend/resource/resource';
+
+type QueryParameters = Record<string, string>;
+
+interface EditFileMetadataConfiguration extends ActionConfiguration {
+  table: string;
+  columnsOnly: Array<string>;
+  returnUrl: string;
+}
+interface DownloadConfiguration extends ActionConfiguration {
+  downloadUrl: string;
+}
+
+interface DeleteFileMetadataConfiguration {
+  ok: string;
+  title: string;
+  content: string;
+}
+
+enum Selectors {
+  fileListFormSelector = 'form[name="fileListForm"]',
+  commandSelector = 'input[name="cmd"]',
+  searchFieldSelector = 'input[name="searchTerm"]',
+  pointerFieldSelector = 'input[name="pointer"]',
+}
+
+/**
+ * @internal
+ */
+export const fileListOpenElementBrowser = 'typo3:filelist:openElementBrowser';
+
+/**
+ * Module: @typo3/filelist/filelist
+ * @exports @typo3/filelist/filelist
+ */
+export default class Filelist {
+  constructor() {
+    new RegularEvent(fileListOpenElementBrowser, (event: CustomEvent): void => {
+      const url = new URL(event.detail.actionUrl, window.location.origin);
+
+      url.searchParams.set('expandFolder', event.detail.identifier);
+      url.searchParams.set('mode', event.detail.mode);
+
+      const modal = Modal.advanced({
+        type: Modal.types.iframe,
+        content: url.toString(),
+        size: Modal.sizes.large
+      });
+      modal.addEventListener('typo3-modal-hidden', (): void => {
+        // @todo: this needs to be done when a folder was created. Apparently, backend user signals are not parsed in
+        //        the modal's context. The best solution is probably to reload the "document space" via AJAX.
+        top.list_frame.document.location.reload();
+      });
+    }).bindTo(document);
+
+    // Filelist resource events
+    new RegularEvent(FileListActionEvent.primary, (event: CustomEvent): void => {
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      const resourceElement: HTMLElement = detail.trigger.closest('[data-default-language-access]') as HTMLElement;
+      if (resource.type === 'file' && resourceElement !== null) {
+        const formEngineUrl = new URL(top.TYPO3.settings.FormEngine.moduleUrl, window.location.origin);
+        if (resource.metaUid > 0) {
+          formEngineUrl.searchParams.set('edit[sys_file_metadata][' + resource.metaUid + ']', 'edit');
+        } else {
+          formEngineUrl.searchParams.set('edit[sys_file_metadata][0]', 'new');
+          formEngineUrl.searchParams.set('defVals[sys_file_metadata][file]', resource.uid.toString(10));
+        }
+        formEngineUrl.searchParams.set('returnUrl', Filelist.getReturnUrl(''));
+        window.location.href = formEngineUrl.toString();
+      }
+      if (resource.type === 'folder') {
+        const parameters = Filelist.parseQueryParameters(document.location);
+        parameters.id = resource.identifier;
+        const url = new URL(window.location.pathname, window.location.origin);
+        for (const [key, value] of Object.entries(parameters)) {
+          url.searchParams.set(key, value);
+        }
+        window.location.href = url.toString();
+      }
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.primaryContextmenu, (event: CustomEvent): void => {
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      ContextMenu.show('sys_file', resource.identifier, '', '', '', detail.trigger, detail.event as PointerEvent);
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.show, (event: CustomEvent): void => {
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      Filelist.openInfoPopup('_' + resource.type.toUpperCase(), resource.identifier);
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.download, (event: CustomEvent): void => {
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      this.triggerDownload([resource], detail.url, detail.trigger);
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.updateOnlineMedia, (event: CustomEvent): void => {
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      this.updateOnlineMedia(resource, detail.url);
+    }).bindTo(document);
+
+    DocumentService.ready().then((): void => {
+      Filelist.processTriggers();
+
+      new RegularEvent('click', (e: Event, trigger: HTMLAnchorElement): void => {
+        e.preventDefault();
+
+        document.dispatchEvent(new CustomEvent(fileListOpenElementBrowser, {
+          detail: {
+            actionUrl: trigger.href,
+            identifier: trigger.dataset.identifier,
+            mode: trigger.dataset.mode,
+          }
+        }));
+      }).delegateTo(document, '.t3js-element-browser');
+    });
+
+    // Respond to multi record selection action events
+    new RegularEvent('multiRecordSelection:action:edit', this.editFileMetadata).bindTo(document);
+    new RegularEvent('multiRecordSelection:action:delete', this.deleteMultiple).bindTo(document);
+    new RegularEvent('multiRecordSelection:action:download', this.downloadFilesAndFolders).bindTo(document);
+    new RegularEvent('multiRecordSelection:action:copyMarked', (event: CustomEvent): void => {
+      Filelist.submitClipboardFormWithCommand('copyMarked', event.target as HTMLButtonElement);
+    }).bindTo(document);
+    new RegularEvent('multiRecordSelection:action:removeMarked', (event: CustomEvent): void => {
+      Filelist.submitClipboardFormWithCommand('removeMarked', event.target as HTMLButtonElement);
+    }).bindTo(document);
+
+    // Respond to browser related clearable event
+    const activeSearch: boolean = (document.querySelector([Selectors.fileListFormSelector, Selectors.searchFieldSelector].join(' ')) as HTMLInputElement)?.value !== '';
+    new RegularEvent('search', (event: Event): void => {
+      const searchField: HTMLInputElement = event.target as HTMLInputElement;
+      if (searchField.value === '' && activeSearch) {
+        (searchField.closest(Selectors.fileListFormSelector) as HTMLFormElement)?.submit();
+      }
+    }).delegateTo(document, Selectors.searchFieldSelector);
+  }
+
+  public static submitClipboardFormWithCommand(cmd: string, target: HTMLButtonElement): void {
+    const fileListForm: HTMLFormElement = target.closest(Selectors.fileListFormSelector);
+    if (!fileListForm) {
+      return;
+    }
+    const commandField: HTMLInputElement = fileListForm.querySelector(Selectors.commandSelector);
+    if (!commandField) {
+      return;
+    }
+    commandField.value = cmd;
+    // In case we just change elements on the clipboard, we try to fetch a possible pointer from the query
+    // parameters, so after the form submit, we get to the same view as before. This is not done for delete
+    // commands, since this may lead to empty sites, in case all elements from the current site are deleted.
+    if (cmd === 'copyMarked' || cmd === 'removeMarked') {
+      const pointerField: HTMLInputElement = fileListForm.querySelector(Selectors.pointerFieldSelector);
+      const pointerValue: string = Filelist.parseQueryParameters(document.location).pointer;
+      if (pointerField && pointerValue) {
+        pointerField.value = pointerValue;
+      }
+    }
+    fileListForm.submit();
+  }
+
+  protected static openInfoPopup(type: string, identifier: string): void {
+    InfoWindow.showItem(type, identifier);
+  }
+
+  private static processTriggers(): void {
+    const mainElement: HTMLElement = document.querySelector('.filelist-main');
+    if (mainElement === null) {
+      return;
+    }
+    // update ModuleStateStorage to the current folder identifier
+    ModuleStateStorage.update('media', mainElement.dataset.filelistCurrentIdentifier);
+  }
+
+  private static parseQueryParameters(location: Location): QueryParameters {
+    const searchParams = new URLSearchParams(location.search);
+    return Object.fromEntries(searchParams.entries());
+  }
+
+  private static getReturnUrl(returnUrl: string): string {
+    if (returnUrl === '') {
+      const form = top.list_frame.document.forms.namedItem('fileListForm');
+      if (form !== null) {
+        returnUrl = form.action;
+      } else {
+        returnUrl = top.list_frame.document.location.pathname + top.list_frame.document.location.search;
+      }
+    }
+    return returnUrl;
+  }
+
+  private deleteMultiple(e: CustomEvent): void {
+    e.preventDefault();
+    const eventDetails: ActionEventDetails = e.detail as ActionEventDetails;
+    const configuration: DeleteFileMetadataConfiguration = eventDetails.configuration;
+    Modal.advanced({
+      title: configuration.title || 'Delete',
+      content: configuration.content || 'Are you sure you want to delete those files and folders?',
+      severity: SeverityEnum.warning,
+      buttons: [
+        {
+          text: TYPO3.lang['button.close'] || 'Close',
+          active: true,
+          btnClass: 'btn-default',
+          trigger: (modalEvent: Event, modal: ModalElement) => modal.hideModal(),
+        },
+        {
+          text: configuration.ok || TYPO3.lang['button.ok'] || 'OK',
+          btnClass: 'btn-' + Severity.getCssClass(SeverityEnum.warning),
+          trigger: (modalEvent: Event, modal: ModalElement) => {
+            Filelist.submitClipboardFormWithCommand('delete', e.target as HTMLButtonElement);
+            modal.hideModal();
+          }
+        }
+      ]
+    });
+  }
+
+  private editFileMetadata(e: CustomEvent): void {
+    e.preventDefault();
+    const eventDetails: ActionEventDetails = e.detail;
+    const configuration: EditFileMetadataConfiguration = eventDetails.configuration;
+    if (!configuration || !configuration.idField || !configuration.table) {
+      return;
+    }
+    const list: Array<string> = [];
+    (eventDetails.checkboxes as NodeListOf<HTMLInputElement>).forEach((checkbox: HTMLInputElement) => {
+      const checkboxContainer: HTMLElement = checkbox.closest(MultiRecordSelectionSelectors.elementSelector);
+      if (checkboxContainer !== null && checkboxContainer.dataset[configuration.idField]) {
+        list.push(checkboxContainer.dataset[configuration.idField]);
+      }
+    });
+
+    if (list.length) {
+      const url = new URL(top.TYPO3.settings.FormEngine.moduleUrl, window.location.origin);
+      url.searchParams.set('edit[' + configuration.table + '][' + list.join(',') + ']', 'edit');
+      url.searchParams.set('returnUrl', Filelist.getReturnUrl(configuration.returnUrl || ''));
+      const columnsOnly = configuration.columnsOnly || [];
+      columnsOnly.forEach((column: string, i: number): void => {
+        url.searchParams.set('columnsOnly[' + configuration.table + '][' + i + ']', column);
+      });
+      window.location.href = url.toString();
+    } else {
+      Notification.warning('The selected elements can not be edited.');
+    }
+  }
+
+  private readonly downloadFilesAndFolders = (event: CustomEvent): void => {
+    event.preventDefault();
+
+    const target: HTMLElement = event.target as HTMLElement;
+    const eventDetails: ActionEventDetails = (event.detail as ActionEventDetails);
+    const configuration: DownloadConfiguration = (eventDetails.configuration as DownloadConfiguration);
+
+    const filesAndFolders: ResourceInterface[] = [];
+    eventDetails.checkboxes.forEach((checkbox: HTMLInputElement) => {
+      if (checkbox.checked) {
+        const element = checkbox.closest(FileListActionSelector.elementSelector) as HTMLInputElement;
+        const resource = FileListActionUtility.getResourceForElement(element);
+        filesAndFolders.unshift(resource);
+      }
+    });
+
+    if (filesAndFolders.length) {
+      this.triggerDownload(filesAndFolders, configuration.downloadUrl, target);
+    } else {
+      Notification.warning(lll('file_download.invalidSelection'));
+    }
+  };
+
+  private triggerDownload(items: ResourceInterface[], downloadUrl: string, button: HTMLElement | null): void {
+    if (items.length === 1) {
+      const item = items.at(0);
+      if (item.type === 'file') {
+        // We deal with a single file in the selection, download directly
+        this.invokeDownload(item.url, item.name);
+        return;
+      }
+    }
+
+    // Add notification about the download being prepared
+    Notification.info(lll('file_download.prepare'), '', 2);
+    // Store the targets' (button) content and replace with a spinner
+    // icon, while the download is being prepared. Also disable the
+    // button for this time to prevent the user from triggering it again.
+    const targetContent: string | null = button?.innerHTML;
+    if (button) {
+      button.setAttribute('disabled', 'disabled');
+      Icons.getIcon('spinner-circle', Icons.sizes.small).then((spinner: string): void => {
+        button.innerHTML = spinner;
+      });
+    }
+
+    // Configure and start the progress bar, while preparing
+    NProgress
+      .configure({ parent: '#typo3-filelist', showSpinner: false })
+      .start();
+
+    const itemIdentifiers = items.map((resource: ResourceInterface) => resource.identifier);
+    (new AjaxRequest(downloadUrl)).post({ items: itemIdentifiers })
+      .then(async (response: AjaxResponse): Promise<void> => {
+        let fileName = response.response.headers.get('Content-Disposition');
+        if (!fileName) {
+          const data = await response.resolve();
+          if (data.success === false && data.status) {
+            Notification.warning(lll('file_download.' + data.status), lll('file_download.' + data.status + '.message'), 10);
+          } else {
+            Notification.error(lll('file_download.error'));
+          }
+          return;
+        }
+        fileName = fileName.substring(fileName.indexOf(' filename=') + 10);
+        const data = await response.raw().arrayBuffer();
+        const blob = new Blob([data], { type: response.raw().headers.get('Content-Type') });
+        const downloadUrl = URL.createObjectURL(blob);
+        this.invokeDownload(downloadUrl, fileName);
+        // Add notification about successful preparation
+        Notification.success(lll('file_download.success'), '', 2);
+      })
+      .catch(() => {
+        Notification.error(lll('file_download.error'));
+      })
+      .finally(() => {
+        // Remove progress bar and restore target (button)
+        NProgress.done();
+        if (button) {
+          button.removeAttribute('disabled');
+          button.innerHTML = targetContent;
+        }
+      });
+  }
+
+  private updateOnlineMedia(resource: ResourceInterface, url: string): void {
+    if (!url || !resource.uid || resource.type !== 'file') {
+      return;
+    }
+
+    NProgress.configure({ parent: '#typo3-filelist', showSpinner: false }).start();
+    (new AjaxRequest(url)).post({ resource: resource })
+      .then(() => {
+        Notification.success(lll('online_media.update.success'));
+      })
+      .catch(() => {
+        Notification.error(lll('online_media.update.error'));
+      })
+      .finally(() => {
+        NProgress.done();
+        window.location.reload();
+      });
+  }
+
+  private invokeDownload(downloadUrl: string, fileName: string): void {
+    const anchorTag = document.createElement('a');
+    anchorTag.href = downloadUrl;
+    anchorTag.download = fileName;
+    document.body.appendChild(anchorTag);
+    anchorTag.click();
+    URL.revokeObjectURL(downloadUrl);
+    document.body.removeChild(anchorTag);
+  }
+}

package/filelist/file-replace.ts

@@ -0,0 +1,37 @@
+/*
+ * 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 RegularEvent from '@typo3/core/event/regular-event';
+import DocumentService from '@typo3/core/document-service';
+
+class FileReplace {
+  constructor() {
+    DocumentService.ready().then((): void => {
+      this.registerEvents();
+    });
+  }
+
+  private registerEvents(): void {
+    new RegularEvent('click', function (this: HTMLElement): void {
+      const targetSelector = this.dataset.filelistClickTarget;
+      (document.querySelector(targetSelector) as HTMLElement).click();
+    }).delegateTo(document.body, '[data-filelist-click-target]:not([data-filelist-click-target=""]');
+
+    new RegularEvent('change', function (this: HTMLInputElement): void {
+      const targetSelector = this.dataset.filelistChangeTarget;
+      (document.querySelector(targetSelector) as HTMLInputElement).value = this.value;
+    }).delegateTo(document.body, '[data-filelist-change-target]:not([data-filelist-change-target=""])');
+  }
+}
+
+export default new FileReplace();

package/filelist/linkbrowser-file-handler.ts

@@ -0,0 +1,94 @@
+/*
+ * 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 LinkBrowser from '@typo3/backend/link-browser';
+import RegularEvent from '@typo3/core/event/regular-event';
+import { FileListActionEvent, type FileListActionDetail } from '@typo3/filelist/file-list-actions';
+import AjaxRequest from '@typo3/core/ajax/ajax-request';
+import type { AjaxResponse } from '@typo3/core/ajax/ajax-response';
+import type { ResourceInterface } from '@typo3/backend/resource/resource';
+import InfoWindow from '@typo3/backend/info-window';
+import Notification from '@typo3/backend/notification';
+import type MessageInterface from '@typo3/backend/ajax-data-handler/message-interface';
+
+class LinkBrowserFileHandler {
+  constructor() {
+
+    new RegularEvent(FileListActionEvent.primary, (event: CustomEvent): void => {
+      event.preventDefault();
+      const detail: FileListActionDetail = event.detail;
+      detail.action = FileListActionEvent.select;
+      document.dispatchEvent(new CustomEvent(FileListActionEvent.select, { detail: detail }));
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.select, (event: CustomEvent): void => {
+      event.preventDefault();
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      if (resource.type === 'file') {
+        this.insertLink(resource);
+      }
+      if (resource.type === 'folder') {
+        this.loadContent(resource);
+      }
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.show, (event: CustomEvent): void => {
+      event.preventDefault();
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      InfoWindow.showItem('_' + resource.type.toUpperCase(), resource.identifier);
+    }).bindTo(document);
+
+  }
+
+  private insertLink(resource: ResourceInterface): void
+  {
+    const request = new AjaxRequest(TYPO3.settings.ajaxUrls.link_resource);
+    request.post({
+      identifier: resource.identifier,
+    }).then(async (success: AjaxResponse): Promise<void> => {
+      const data = await success.resolve();
+      data.status.forEach((message: MessageInterface): void => {
+        Notification.showMessage(message.title, message.message, message.severity);
+      });
+      if (data.success) {
+        LinkBrowser.finalizeFunction(data.link);
+      }
+    });
+  }
+
+  private async loadContent(resource: ResourceInterface): Promise<void>
+  {
+    if (resource.type !== 'folder') {
+      return;
+    }
+    const contentsUrl = document.location.href + '&contentOnly=1&expandFolder=' + resource.identifier;
+    const response = await new AjaxRequest(contentsUrl).get();
+    const html = await response.resolve();
+    const contentContainer = document.querySelector('.element-browser-main-content .element-browser-body') as HTMLElement;
+    contentContainer.innerHTML = html;
+    const tree = document.querySelector('typo3-backend-component-filestorage-browser-tree');
+    if (tree) {
+      const treeNodeIdentifier = encodeURIComponent(resource.identifier);
+      // @todo Support loading the node via rootline, in case the node has not be loaded in the tree yet, see @typo3/backend/tree/tree-module-state
+      const node = tree.nodes.find((node) => node.identifier === treeNodeIdentifier);
+      if (node) {
+        await tree.expandNodeParents(node);
+        tree.selectNode(node, false);
+      }
+    }
+  }
+}
+
+export default new LinkBrowserFileHandler();

package/filelist/linkbrowser-folder-handler.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 LinkBrowser from '@typo3/backend/link-browser';
+import RegularEvent from '@typo3/core/event/regular-event';
+import { FileListActionEvent, type FileListActionDetail } from '@typo3/filelist/file-list-actions';
+import type { ResourceInterface } from '@typo3/backend/resource/resource';
+import InfoWindow from '@typo3/backend/info-window';
+import AjaxRequest from '@typo3/core/ajax/ajax-request';
+import type { AjaxResponse } from '@typo3/core/ajax/ajax-response';
+import Notification from '@typo3/backend/notification';
+import type MessageInterface from '@typo3/backend/ajax-data-handler/message-interface';
+
+class LinkBrowserFolderHandler {
+  constructor() {
+
+    new RegularEvent('click', (event: PointerEvent, target: HTMLElement): void => {
+      event.preventDefault();
+      LinkBrowser.finalizeFunction(target.dataset.linkbrowserLink);
+    }).delegateTo(document, '[data-linkbrowser-link]');
+
+    new RegularEvent(FileListActionEvent.primary, (event: CustomEvent): void => {
+      event.preventDefault();
+      const detail: FileListActionDetail = event.detail;
+      detail.action = FileListActionEvent.select;
+      document.dispatchEvent(new CustomEvent(FileListActionEvent.select, { detail: detail }));
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.select, (event: CustomEvent): void => {
+      event.preventDefault();
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      if (resource.type === 'folder') {
+        this.insertLink(resource);
+      }
+    }).bindTo(document);
+
+    new RegularEvent(FileListActionEvent.show, (event: CustomEvent): void => {
+      event.preventDefault();
+      const detail: FileListActionDetail = event.detail;
+      const resource = detail.resources[0];
+      InfoWindow.showItem('_' + resource.type.toUpperCase(), resource.identifier);
+    }).bindTo(document);
+
+  }
+
+  private insertLink(resource: ResourceInterface): void
+  {
+    const request = new AjaxRequest(TYPO3.settings.ajaxUrls.link_resource);
+    request.post({
+      identifier: resource.identifier,
+    }).then(async (success: AjaxResponse): Promise<void> => {
+      const data = await success.resolve();
+      data.status.forEach((message: MessageInterface): void => {
+        Notification.showMessage(message.title, message.message, message.severity);
+      });
+      if (data.success) {
+        LinkBrowser.finalizeFunction(data.link);
+      }
+    });
+  }
+}
+
+export default new LinkBrowserFolderHandler();