@manuscripts/style-guide 1.3.2-LEAN-2859-1 → 1.3.2-LEAN-2880-1

package/dist/cjs/lib/inlineFiles.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_schema_1 = require("@manuscripts/json-schema");
+const transform_1 = require("@manuscripts/transform");
+const util_1 = require("../components/FileManager/util");
+const getFigureData = (element, modelMap, attachmentsMap) => {
+    const attachments = [];
+    element.containedObjectIDs.map((id) => {
+        const object = modelMap.get(id);
+        if (object && object.objectType === json_schema_1.ObjectTypes.Figure) {
+            const figure = object;
+            if (figure.src) {
+                const attachment = attachmentsMap.get(figure.src.replace('attachment:', ''));
+                if (attachment) {
+                    attachment.modelId = id;
+                    attachments.push(attachment);
+                }
+            }
+        }
+    });
+    return {
+        id: element._id,
+        attachments,
+    };
+};
+exports.default = (modelMap, attachments) => {
+    const files = [];
+    const attachmentsMap = new Map(attachments.map((attachment) => [attachment.id, attachment]));
+    const { graphicalAbstractFigureId, figureElement } = getAuxiliaryObjects(modelMap);
+    if (graphicalAbstractFigureId) {
+        const element = modelMap.get(graphicalAbstractFigureId);
+        files.unshift(Object.assign(Object.assign({}, getFigureData(element, modelMap, attachmentsMap)), { label: `Graphical Abstract`, type: util_1.FileType.GraphicalAbstract }));
+    }
+    figureElement.map((id, index) => {
+        const element = modelMap.get(id);
+        files.push(Object.assign(Object.assign({}, getFigureData(element, modelMap, attachmentsMap)), { label: `Figure ${index + 1}`, type: util_1.FileType.Figure }));
+    });
+    return files;
+};
+const getAuxiliaryObjects = (modelMap) => {
+    var _a, _b;
+    let graphicalAbstractFigureId, figureElementIds = [];
+    const tableElementIds = [], orderObjects = {};
+    for (const model of modelMap.values()) {
+        switch (model.objectType) {
+            case json_schema_1.ObjectTypes.Section: {
+                const section = model;
+                if (section.category === 'MPSectionCategory:abstract-graphical') {
+                    graphicalAbstractFigureId = (_a = section.elementIDs) === null || _a === void 0 ? void 0 : _a.find((id) => {
+                        const obj = modelMap.get(id);
+                        return obj && (0, transform_1.hasObjectType)(json_schema_1.ObjectTypes.FigureElement)(obj);
+                    });
+                }
+                else {
+                    (_b = section.elementIDs) === null || _b === void 0 ? void 0 : _b.map((elementId) => {
+                        const element = modelMap.get(elementId);
+                        if (!element) {
+                            return;
+                        }
+                        switch (element.objectType) {
+                            case json_schema_1.ObjectTypes.FigureElement:
+                                figureElementIds.push(element._id);
+                                break;
+                            case json_schema_1.ObjectTypes.TableElement:
+                                tableElementIds.push(element._id);
+                                break;
+                        }
+                    });
+                }
+                break;
+            }
+            case json_schema_1.ObjectTypes.ElementsOrder: {
+                const elementsOrder = model;
+                orderObjects[elementsOrder.elementType] = elementsOrder;
+            }
+        }
+    }
+    if (graphicalAbstractFigureId) {
+        figureElementIds = figureElementIds.filter((id) => id != graphicalAbstractFigureId);
+    }
+    return {
+        graphicalAbstractFigureId,
+        figureElement: sortAuxiliaryObject(figureElementIds, orderObjects[json_schema_1.ObjectTypes.FigureElement]),
+        tableElement: sortAuxiliaryObject(tableElementIds, orderObjects[json_schema_1.ObjectTypes.TableElement]),
+    };
+};
+const sortAuxiliaryObject = (auxiliaryObjectIds, orderObject) => {
+    if (!orderObject) {
+        return auxiliaryObjectIds;
+    }
+    return auxiliaryObjectIds.sort((a, b) => orderObject.elements.indexOf(a) - orderObject.elements.indexOf(b));
+};

package/dist/es/components/FileManager/ConfirmationPopUp.js

@@ -0,0 +1,62 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ObjectTypes } from '@manuscripts/json-schema';
+import { buildSupplementaryMaterial, getModelsByType, } from '@manuscripts/transform';
+import React, { useCallback, useContext } from 'react';
+import { Category, Dialog } from '../Dialog';
+import { FileManagerContext } from './FileManagerProvider';
+import { actions } from './FileSectionState';
+import { FileSectionType } from './util';
+export const ConfirmationPopUp = ({ popupHeader, popUpMessage, isOpen, handleClose, handleMove }) => {
+    return (React.createElement(Dialog, { isOpen: isOpen, category: Category.confirmation, header: popupHeader, message: popUpMessage, actions: {
+            primary: {
+                action: handleMove,
+                title: 'Move',
+            },
+            secondary: {
+                action: handleClose,
+                title: 'Cancel',
+            },
+        } }));
+};
+export const MoveFilePopup = ({ dispatch, }) => {
+    const { moveFilePopup: { isOpen, fileSection, attachmentId }, saveModel, deleteModel, modelMap, getAttachments, setMoveFilePopupData, } = useContext(FileManagerContext);
+    const isSupplement = fileSection === FileSectionType.Supplements;
+    const message = {
+        popupHeader: `Are you sure you want to move this file to “${(!isSupplement && 'Supplements') || 'Other files'}”?`,
+        popUpMessage: `The file will be removed from the “${(isSupplement && 'Supplements') || 'Other files'}” and added to “${(!isSupplement && 'Supplements') || 'Other files'}”.`,
+    };
+    const closePopup = useCallback(() => setMoveFilePopupData({
+        isOpen: false,
+        fileSection: fileSection,
+    }), [fileSection, setMoveFilePopupData]);
+    const showSuccessMessage = useCallback(() => dispatch(actions.HANDLE_SUCCESS_MESSAGE(`File moved to ${(isSupplement && 'Other files') || 'Supplements'}.`, fileSection)), [dispatch, fileSection, isSupplement]);
+    const moveToSupplement = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        closePopup();
+        const attachment = getAttachments().find(({ id }) => id === attachmentId);
+        if (!attachment) {
+            return;
+        }
+        const model = buildSupplementaryMaterial(attachment.name, `attachment:${attachment.id}`);
+        yield saveModel(Object.assign(Object.assign({}, model), { title: attachment.name, href: `attachment:${attachment.id}` }));
+        showSuccessMessage();
+    }), [getAttachments, saveModel, showSuccessMessage, closePopup, attachmentId]);
+    const moveSupplementToOtherFiles = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        closePopup();
+        const model = getModelsByType(modelMap, ObjectTypes.Supplement).find(({ href }) => (href === null || href === void 0 ? void 0 : href.replace('attachment:', '')) === attachmentId);
+        if (!model) {
+            return;
+        }
+        yield deleteModel(model._id);
+        showSuccessMessage();
+    }), [attachmentId, closePopup, deleteModel, modelMap, showSuccessMessage]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(ConfirmationPopUp, Object.assign({ isOpen: isOpen }, message, { handleMove: () => (!isSupplement && moveToSupplement()) || moveSupplementToOtherFiles(), handleClose: closePopup }))));
+};

package/dist/es/components/FileManager/DragItemArea.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import styled from 'styled-components';
+import DragAndDropFileIcon from '../icons/drag-drop-file-icon';
+export const DragItemArea = ({ text }) => {
+    return (React.createElement(Container, null,
+        React.createElement("div", null,
+            React.createElement(DragAndDropFileIcon, null)),
+        text));
+};
+const Container = styled.div `
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  font-size: 14px;
+  line-height: 24px;
+  font-family: ${(props) => props.theme.font.family.Lato};
+  color: ${(props) => props.theme.colors.text.onLight};
+  padding: 32px 0;
+  text-align: center;
+`;

package/dist/es/components/FileManager/FileManager.js

@@ -1,33 +1,141 @@
-import React, { createContext } from 'react';
-import { useFiles } from '../../index';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ObjectTypes, } from '@manuscripts/json-schema';
+import { buildSupplementaryMaterial, getModelsByType, } from '@manuscripts/transform';
+import React, { createContext, useCallback, useReducer } from 'react';
+import ReactTooltip from 'react-tooltip';
+import { FileSectionType, useFiles } from '../../index';
 import { InspectorTab, InspectorTabList, InspectorTabPanel, InspectorTabPanels, InspectorTabs, } from '../Inspector';
 import { InspectorSection } from '../InspectorSection';
-import { DragLayer } from './DragLayer';
+import { MoveFilePopup } from './ConfirmationPopUp';
 import { FileManagerProvider } from './FileManagerProvider';
+import { DraggableFileSectionItem } from './FileSectionItem/DraggableFileSectionItem';
+import { DragLayer } from './FileSectionItem/DragLayer';
+import { FileSectionItem, } from './FileSectionItem/FileSectionItem';
+import { actions, getInitialState, reducer } from './FileSectionState';
+import { FilesSection } from './FilesSection';
 import { InlineFilesSection } from './InlineFilesSection';
-import { OtherFilesSection } from './OtherFilesSection';
-import { SupplementsSection } from './SupplementsSection';
-import { Tooltip } from './Tooltip';
+import { TooltipDiv } from './TooltipDiv';
+import { generateAttachmentsTitles } from './util';
 export const PermissionsContext = createContext(null);
-export const FileManager = ({ files, fileManagement, modelMap, saveModel, deleteModel, enableDragAndDrop, can, }) => {
-    const { inlineFiles, supplements, otherFiles } = useFiles(modelMap, files);
-    return (React.createElement(FileManagerProvider, { saveModel: saveModel, deleteModel: deleteModel, modelMap: modelMap, fileManagement: fileManagement },
+export const FileManager = ({ modelMap, saveModel, deleteModel, enableDragAndDrop, can, fileManagement: { getAttachments, replace, upload }, addAttachmentToState, }) => {
+    const [state, dispatch] = useReducer(reducer, getInitialState());
+    const handleReplaceFile = useCallback((attachmentId, name, file) => __awaiter(void 0, void 0, void 0, function* () {
+        dispatch(actions.HANDLE_UPLOAD_ACTION());
+        const res = yield replace(attachmentId, name, file);
+        dispatch(actions.HANDLE_FINISH_UPLOAD());
+        if (res) {
+            dispatch(actions.HANDLE_SUCCESS_MESSAGE('File uploaded successfully.'));
+        }
+        return res;
+    }), [replace]);
+    const handleUploadFile = useCallback((file) => __awaiter(void 0, void 0, void 0, function* () {
+        dispatch(actions.HANDLE_UPLOAD_ACTION());
+        const res = yield upload(file);
+        dispatch(actions.HANDLE_FINISH_UPLOAD());
+        if (res) {
+            dispatch(actions.HANDLE_SUCCESS_MESSAGE('File uploaded successfully.', FileSectionType.OtherFile));
+        }
+        return res;
+    }), [upload]);
+    const handleUploadFileWithSupplement = useCallback((file) => __awaiter(void 0, void 0, void 0, function* () {
+        dispatch(actions.HANDLE_UPLOAD_ACTION());
+        const response = yield upload(file);
+        if (typeof response === 'object') {
+            const { id, name } = response;
+            yield saveModel(buildSupplementaryMaterial(name, `attachment:${id}`));
+        }
+        dispatch(actions.HANDLE_FINISH_UPLOAD());
+        if (response) {
+            dispatch(actions.HANDLE_SUCCESS_MESSAGE('File uploaded successfully.', FileSectionType.Supplements));
+        }
+        return response;
+    }), [upload, saveModel]);
+    const handleSupplementReplace = useCallback((attachment, oldAttachmentId) => __awaiter(void 0, void 0, void 0, function* () {
+        const model = getModelsByType(modelMap, ObjectTypes.Supplement).find(({ href }) => (href === null || href === void 0 ? void 0 : href.replace('attachment:', '')) === oldAttachmentId);
+        yield saveModel(Object.assign(Object.assign({}, model), { title: attachment.name, href: `attachment:${attachment.id}` }));
+    }), [modelMap, saveModel]);
+    const handleDownload = useCallback((url) => {
+        window.location.assign(url);
+    }, []);
+    const handleUpdateInline = useCallback((modelId, attachment) => __awaiter(void 0, void 0, void 0, function* () {
+        const figureModel = modelMap.get(modelId);
+        figureModel.src = `attachment:${attachment.id}`;
+        if (addAttachmentToState) {
+            addAttachmentToState(Object.assign({}, attachment));
+        }
+        yield saveModel(figureModel);
+    }), [modelMap, saveModel, addAttachmentToState]);
+    const attachments = getAttachments();
+    const { otherFiles, supplementFiles, inlineFiles } = useFiles(modelMap, attachments);
+    const handleDetachFile = (attachmentId, modelId) => {
+        const model = modelMap.get(modelId);
+        if (model) {
+            saveModel(Object.assign(Object.assign({}, model), { src: '' }));
+        }
+    };
+    const getFileSectionExternalFile = (fileSection) => {
+        const isSupplementOrOtherFilesTab = fileSection === FileSectionType.Supplements ||
+            fileSection === FileSectionType.OtherFile;
+        const isOtherFilesTab = fileSection === FileSectionType.OtherFile;
+        const itemsData = (fileSection === FileSectionType.Supplements && supplementFiles) ||
+            otherFiles;
+        const itemsDataWithTitle = generateAttachmentsTitles(itemsData, fileSection);
+        const filesItems = itemsDataWithTitle.map((element) => {
+            const itemProps = {
+                fileSection,
+                externalFile: element.externalFile,
+                title: element.title,
+                showAttachmentName: isSupplementOrOtherFilesTab,
+                showReplaceAction: !isOtherFilesTab,
+                handleDownload,
+                handleReplace: handleReplaceFile,
+                handleSupplementReplace,
+                dispatch: dispatch,
+            };
+            if (enableDragAndDrop && isSupplementOrOtherFilesTab) {
+                return (React.createElement(DraggableFileSectionItem, Object.assign({}, itemProps, { key: element.externalFile.id })));
+            }
+            else {
+                return (React.createElement(FileSectionItem, Object.assign({}, itemProps, { key: element.externalFile.id, isEditor: enableDragAndDrop })));
+            }
+        });
+        return filesItems;
+    };
+    return (React.createElement(FileManagerProvider, { saveModel: saveModel, modelMap: modelMap, deleteModel: deleteModel, getAttachments: getAttachments },
         React.createElement(DragLayer, null),
         React.createElement(PermissionsContext.Provider, { value: can },
-            React.createElement(InspectorSection, { title: 'Files', contentStyles: { margin: '24px 16px' } },
+            React.createElement(InspectorSection, { title: 'Files', contentStyles: { margin: '24px' } },
                 React.createElement(InspectorTabs, { defaultIndex: 0, style: { overflow: 'visible' } },
                     React.createElement(InspectorTabList, null,
                         React.createElement(InspectorTab, { "data-for": "inline", "data-tip": true }, "Inline files"),
-                        React.createElement(Tooltip, { id: "inline", place: "bottom", offset: { bottom: -11 }, effect: "solid", className: "tooltip" }, "Files that can be found inline in the manuscript."),
+                        React.createElement(TooltipDiv, null,
+                            React.createElement(ReactTooltip, { id: "inline", place: "bottom", offset: { bottom: -11 }, effect: "solid", className: "tooltip" },
+                                React.createElement("div", null,
+                                    "Files that can be found inline ",
+                                    React.createElement("br", null),
+                                    " in the manuscript."))),
                         React.createElement(InspectorTab, { "data-for": "supplements", "data-tip": true }, "Supplements"),
-                        React.createElement(Tooltip, { id: "supplements", place: "bottom", offset: { bottom: -11 }, effect: "solid", className: "tooltip" }, "Files that were marked as supplements."),
+                        React.createElement(TooltipDiv, null,
+                            React.createElement(ReactTooltip, { id: "supplements", place: "bottom", offset: { bottom: -11 }, effect: "solid", className: "tooltip" },
+                                React.createElement("div", null, "Files that were marked as supplementaries."))),
                         React.createElement(InspectorTab, { "data-for": "other", "data-tip": true }, "Other files"),
-                        React.createElement(Tooltip, { id: "other", place: "bottom", offset: { bottom: -11 }, effect: "solid", className: "tooltip" }, "Files excluded from the final submission.")),
+                        React.createElement(TooltipDiv, null,
+                            React.createElement(ReactTooltip, { id: "other", place: "bottom", offset: { bottom: -11 }, effect: "solid", className: "tooltip" },
+                                React.createElement("div", null, "Files excluded from the final submission.")))),
                     React.createElement(InspectorTabPanels, { style: { overflowY: 'visible', position: 'relative' } },
                         React.createElement(InspectorTabPanel, null,
-                            React.createElement(InlineFilesSection, { elements: inlineFiles, isEditor: enableDragAndDrop })),
+                            React.createElement(InlineFilesSection, { inlineFiles: inlineFiles, handleReplace: replace, handleDownload: handleDownload, handleUpdateInline: handleUpdateInline, handleDetachFile: handleDetachFile, isEditor: enableDragAndDrop, dispatch: dispatch })),
                         React.createElement(InspectorTabPanel, null,
-                            React.createElement(SupplementsSection, { supplements: supplements })),
+                            React.createElement(FilesSection, { enableDragAndDrop: enableDragAndDrop, handleUpload: handleUploadFileWithSupplement, fileSection: FileSectionType.Supplements, filesItem: getFileSectionExternalFile(FileSectionType.Supplements), state: state, dispatch: dispatch })),
                         React.createElement(InspectorTabPanel, null,
-                            React.createElement(OtherFilesSection, { files: otherFiles }))))))));
+                            React.createElement(FilesSection, { enableDragAndDrop: enableDragAndDrop, handleUpload: handleUploadFile, fileSection: FileSectionType.OtherFile, filesItem: getFileSectionExternalFile(FileSectionType.OtherFile), state: state, dispatch: dispatch }))))),
+            React.createElement(MoveFilePopup, { dispatch: dispatch }))));
 };

package/dist/es/components/FileManager/FileManagerProvider.js

@@ -1,12 +1,17 @@
-import React, { createContext } from 'react';
+import React, { createContext, useState } from 'react';
 export const FileManagerContext = createContext({
     saveModel: () => '',
+    moveFilePopup: { isOpen: false },
+    setMoveFilePopupData: () => '',
 });
-export const FileManagerProvider = ({ children, saveModel, deleteModel, modelMap, fileManagement }) => {
+export const FileManagerProvider = ({ children, saveModel, deleteModel, modelMap, getAttachments }) => {
+    const [moveFilePopup, setMoveFilePopupData] = useState({ isOpen: false });
     return (React.createElement(FileManagerContext.Provider, { value: {
             saveModel,
             deleteModel,
             modelMap,
-            fileManagement,
+            getAttachments,
+            moveFilePopup,
+            setMoveFilePopupData,
         } }, children));
 };

package/dist/es/components/FileManager/{DragLayer.js → FileSectionItem/DragLayer.js}

@@ -1,9 +1,7 @@
 import React, { useCallback } from 'react';
 import { useDragLayer } from 'react-dnd';
 import styled from 'styled-components';
-import { FileContainer } from './FileContainer';
-import { FileCreatedDate } from './FileCreatedDate';
-import { FileName } from './FileName';
+import { FileSectionItem } from './FileSectionItem';
 function getItemStyles(initialOffset, currentOffset) {
     if (!initialOffset || !currentOffset) {
         return {
@@ -27,10 +25,8 @@ export const DragLayer = () => {
     }));
     const renderItem = useCallback(() => {
         switch (itemType) {
-            case 'file':
-                return (React.createElement(DraggableFileContainer, null,
-                    React.createElement(FileName, { file: item.file }),
-                    item.file.createdDate && React.createElement(FileCreatedDate, { file: item.file })));
+            case 'FileSectionItem':
+                return (React.createElement(CustomFileSectionItem, { title: item.title, externalFile: item.externalFile, showAttachmentName: item.showAttachmentName, withDot: item.withDot, showSecondaryActions: false, style: { width: item.width } }));
             default:
                 return null;
         }
@@ -38,7 +34,8 @@ export const DragLayer = () => {
     if (!isDragging) {
         return null;
     }
-    return (React.createElement(Container, { style: getItemStyles(initialOffset, currentOffset) }, renderItem()));
+    return (React.createElement(Container, null,
+        React.createElement("div", { style: getItemStyles(initialOffset, currentOffset) }, renderItem())));
 };
 const Container = styled.div `
   position: fixed;
@@ -46,12 +43,13 @@ const Container = styled.div `
   z-index: 999;
   left: 0;
   top: 0;
-  max-width: 400px;
+  width: 100%;
+  height: 100%;
 `;
-const DraggableFileContainer = styled(FileContainer) `
+const CustomFileSectionItem = React.memo(styled(FileSectionItem) `
   padding: 16px 32px;
   background: #f2fbfc;
   border: 1px solid #bce7f6;
-  box-shadow: 0 4px 9px rgba(0, 0, 0, 0.3);
+  box-shadow: 0px 4px 9px rgba(0, 0, 0, 0.3);
   border-radius: 6px;
-`;
+`);

package/dist/es/components/FileManager/FileSectionItem/DraggableFileSectionItem.js

@@ -0,0 +1,46 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { useDrag } from 'react-dnd';
+import { getEmptyImage } from 'react-dnd-html5-backend';
+import styled from 'styled-components';
+import { FileSectionItem } from './FileSectionItem';
+const itemPlaceHolderDraggingStyle = {
+    background: '#FAFAFA',
+    borderRadius: '6px',
+    height: '104px',
+};
+const draggingItemStyle = {
+    opacity: 0,
+    height: 0,
+};
+export const DraggableFileSectionItem = (props) => {
+    const [draggingItemWidth, setDraggingItemWidth] = useState('100%');
+    const itemPlaceholderRef = useRef();
+    const [{ isDragging }, dragRef, preview] = useDrag({
+        item: {
+            id: props.title,
+            title: props.title,
+            externalFile: props.externalFile,
+            showAttachmentName: props.showAttachmentName,
+            width: draggingItemWidth,
+            type: 'FileSectionItem',
+        },
+        collect: (monitor) => ({
+            isDragging: monitor.isDragging(),
+        }),
+    });
+    useEffect(() => {
+        if (itemPlaceholderRef && itemPlaceholderRef.current) {
+            setDraggingItemWidth(itemPlaceholderRef.current.offsetWidth + 'px');
+        }
+    }, []);
+    useEffect(() => {
+        preview(getEmptyImage());
+    }, [preview]);
+    return (React.createElement(ItemDraggingPlaceholderContainer, { style: isDragging ? itemPlaceHolderDraggingStyle : {}, ref: itemPlaceholderRef },
+        React.createElement(FileSectionItem, Object.assign({ style: isDragging ? draggingItemStyle : {}, dragRef: dragRef }, props))));
+};
+const ItemDraggingPlaceholderContainer = styled.div `
+  background: ${(props) => props.theme.colors.background.primary};
+  width: 100%;
+  position: relative;
+`;

package/dist/es/components/FileManager/FileSectionItem/FileInfo.js

@@ -0,0 +1,85 @@
+import { format } from 'date-fns';
+import React, { useContext } from 'react';
+import ReactTooltip from 'react-tooltip';
+import styled from 'styled-components';
+import { PermissionsContext } from '../FileManager';
+import { TooltipDiv } from '../TooltipDiv';
+export const FileInfo = ({ showAttachmentName, title, fileAttachmentName, fileExtension, attachmentId, dispatch, fileCreatedDate, }) => {
+    const fileName = fileAttachmentName.substring(0, fileAttachmentName.lastIndexOf('.'));
+    const can = useContext(PermissionsContext);
+    return (React.createElement(FileInfoContainer, null,
+        React.createElement(FileNameTitleContainer, null,
+            React.createElement(FileTitle, null,
+                !showAttachmentName ? fileName : title,
+                showAttachmentName && ':'),
+            showAttachmentName && (React.createElement(FileNameContainer, null,
+                React.createElement(FileName, null, fileName),
+                React.createElement("div", null,
+                    ".",
+                    fileExtension))),
+            fileCreatedDate && (React.createElement(FileDateContainer, { "data-tip": "tooltip-content" },
+                React.createElement(FileDate, null, format(new Date(fileCreatedDate), 'M/d/yy, HH:mm')),
+                React.createElement(TooltipDiv, null,
+                    React.createElement(ReactTooltip, { place: "bottom", offset: { top: 0 }, effect: "solid", className: "tooltip" },
+                        React.createElement("div", null, "File uploaded"))))))));
+};
+export const FileDateContainer = styled.div `
+  line-height: 20px;
+  overflow: hidden;
+  width: 100%;
+  display: none;
+  justify-content: flex-end;
+`;
+export const FileInfoContainer = styled.div `
+  margin-left: 8px;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: start;
+  width: 100%;
+
+  &:hover ${FileDateContainer} {
+    display: flex;
+  }
+`;
+export const FileNameTitleContainer = styled.div `
+  display: flex;
+  width: 100%;
+  align-items: baseline;
+`;
+export const FileTitle = styled.div `
+  color: ${(props) => props.theme.colors.text.primary};
+  font-weight: bold;
+  font-size: 16px;
+  line-height: 20px;
+  margin-right: 4px;
+  white-space: nowrap;
+`;
+export const FileNameContainer = styled.div `
+  display: flex;
+  color: ${(props) => props.theme.colors.text.primary};
+  font-weight: normal;
+  font-size: 16px;
+  line-height: 20px;
+  overflow: hidden;
+  width: 100%;
+`;
+export const FileName = styled.div `
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  overflow: hidden;
+  width: 50px;
+`;
+export const FileDate = styled.div `
+  font-size: font-size: ${(props) => props.theme.font.size.small};
+`;
+export const FileDescription = styled.div `
+  color: ${(props) => props.theme.colors.text.secondary};
+  font-size: 14px;
+  line-height: 20px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  overflow: hidden;
+  width: 100%;
+`;

package/dist/es/components/FileManager/FileSectionItem/FileSectionItem.js

@@ -0,0 +1,88 @@
+import React from 'react';
+import styled from 'styled-components';
+import { useDropdown } from '../../../hooks/use-dropdown';
+import { DropdownContainer } from '../../Dropdown';
+import { CloseOIcon } from '../../icons/';
+import DotsIcon from '../../icons/dots-icon';
+import { FileInfo } from './FileInfo';
+import { FileTypeIcon } from './FileTypeIcon';
+import { ItemActions } from './ItemActions';
+export const FileSectionItem = ({ fileSection, externalFile, title, showAttachmentName = false, showReplaceAction = true, handleDownload, handleReplace, handleSupplementReplace, dispatch, dragRef, className, style, onClose, isEditor, }) => {
+    const { isOpen, toggleOpen, wrapperRef } = useDropdown();
+    const fileExtension = externalFile.name.substring(externalFile.name.lastIndexOf('.') + 1);
+    const isMainManuscript = externalFile.type.label === 'main-manuscript';
+    const isSelected = externalFile.id == window.location.hash.substr(1);
+    return (React.createElement(Item, { ref: dragRef, className: className, style: style },
+        React.createElement(ItemContainer, { onClick: () => {
+                window.location.hash =
+                    isEditor && !isSelected ? `#${externalFile.id}` : '#';
+                if (isSelected) {
+                    window.location.hash = `#${externalFile.id}`;
+                }
+            } },
+            React.createElement(FileTypeIcon, { withDot: isMainManuscript, fileExtension: fileExtension, alt: externalFile.name }),
+            React.createElement(FileInfo, { fileExtension: fileExtension, fileCreatedDate: externalFile.createdDate, showAttachmentName: showAttachmentName, fileAttachmentName: externalFile.name, title: title, attachmentId: externalFile.id, dispatch: dispatch })),
+        onClose && (React.createElement(IconCloseButton, { onClick: (e) => {
+                e.preventDefault();
+                onClose();
+            } },
+            React.createElement(CloseOIcon, { color: '#6E6E6E' }))),
+        handleDownload && handleReplace && (React.createElement(DropdownContainer, { ref: wrapperRef },
+            React.createElement(ActionsIcon, { onClick: toggleOpen, type: "button", "aria-label": "Download or Replace", "aria-pressed": isOpen },
+                React.createElement(DotsIcon, null)),
+            isOpen && (React.createElement(ItemActions, { fileSection: fileSection, isMainManuscript: isMainManuscript, replaceAttachmentHandler: handleReplace, showReplaceAction: showReplaceAction, downloadAttachmentHandler: handleDownload, handleSupplementReplace: handleSupplementReplace, attachmentId: externalFile.id, fileName: externalFile.name, publicUrl: externalFile.link, hideActionList: toggleOpen, dispatch: dispatch }))))));
+};
+const IconCloseButton = styled.button `
+  border: none;
+  background: transparent;
+  cursor: pointer;
+  padding: 0 8px;
+  align-self: flex-start;
+  &:hover {
+    opacity: 0.5;
+  }
+`;
+export const ActionsIcon = styled.button `
+  visibility: hidden;
+  border: none;
+  background: transparent;
+  cursor: pointer;
+  padding: 0 8px;
+  &:focus {
+    outline: none;
+  }
+  &:hover svg circle {
+    fill: #1a9bc7;
+  }
+`;
+export const Item = styled.div `
+  display: flex;
+  font-family: ${(props) => props.theme.font.family.Lato};
+  padding: 20px 15px;
+  cursor: pointer;
+  box-sizing: border-box;
+  width: 100%;
+  position: relative;
+
+  &:hover,
+  &:focus {
+    background: #f2fbfc;
+  }
+
+  &:hover ${ActionsIcon} {
+    visibility: visible;
+  }
+
+  ${DropdownContainer} {
+    position: absolute;
+    top: 24px;
+    right: 0;
+    margin-right: 8px;
+  }
+`;
+export const ItemContainer = styled.div `
+  display: flex;
+  min-width: calc(100% - 8px);
+  padding-right: 4px;
+  box-sizing: border-box;
+`;