@linagora/twake-mui 10.5.0 → 11.0.0

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+# @linagora/twake-mui [11.0.0](https://github.com/linagora/twake-ui/compare/@linagora/twake-mui@10.5.1...@linagora/twake-mui@11.0.0) (2026-10-08)
+
+
+### Bug Fixes
+
+* **twake-mui:** Reposition BottomSheet when the window is resized ([7036375](https://github.com/linagora/twake-ui/commit/70363755a1f61e2ca77d1fa3ac9132e3e33fd00e))
+
+
+### Features
+
+* **twake-mui:** Add ActionsMenu locales ([f0e09cb](https://github.com/linagora/twake-ui/commit/f0e09cb0f6ae7e8c3e988bc5b62fc7190c07f475))
+* **twake-mui:** Migrate ActionsMenu from cozy-ui ([7b12778](https://github.com/linagora/twake-ui/commit/7b12778d86948e5c53fe9b2e16555ed966e64dc6))
+* **twake-mui:** Migrate ActionsMenu predefined actions from cozy-ui ([7f66436](https://github.com/linagora/twake-ui/commit/7f6643633dfa1d6e65f402ee26af223e3ac5d440))
+
+
+### BREAKING CHANGES
+
+* **twake-mui:** cozy-intent is now a required peer dependency of
+@linagora/twake-mui. Apps must install cozy-intent >=2.29.1.
+
+## @linagora/twake-mui [10.5.1](https://github.com/linagora/twake-ui/compare/@linagora/twake-mui@10.5.0...@linagora/twake-mui@10.5.1) (2026-10-07)
+
+
+### Bug Fixes
+
+* **twake-mui:** Rename spaceOverlay.ts to connectSpaceOverlay.ts ([20754d1](https://github.com/linagora/twake-ui/commit/20754d1efdc12bf1f40331042de0ff16035f6aee))
+
 # @linagora/twake-mui [10.5.0](https://github.com/linagora/twake-ui/compare/@linagora/twake-mui@10.4.1...@linagora/twake-mui@10.5.0) (2026-10-07)
 
 

package/dist/components/ActionsMenu/Actions/call.d.ts

@@ -0,0 +1,2 @@
+import { Action } from '../types';
+export declare const call: () => Action;

package/dist/components/ActionsMenu/Actions/call.js

@@ -0,0 +1,16 @@
+import { Telephone } from '@linagora/twake-icons';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+export const call = () => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'call',
+        label: t('ActionsMenu.call'),
+        icon: Telephone,
+        action: (docs) => {
+            const target = docs[0]?.phone?.[0]?.number;
+            if (target)
+                window.open(`tel:${target}`, '_self');
+        }
+    });
+};

package/dist/components/ActionsMenu/Actions/copyToClipboard.d.ts

@@ -0,0 +1,2 @@
+import { Action } from '../types';
+export declare const copyToClipboard: () => Action;

package/dist/components/ActionsMenu/Actions/copyToClipboard.js

@@ -0,0 +1,32 @@
+import { Copy } from '@linagora/twake-icons';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+export const copyToClipboard = () => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'copyToClipboard',
+        label: t('ActionsMenu.copyToClipboard.copy'),
+        icon: Copy,
+        action: async (_docs, { showAlert, copyValue }) => {
+            if (!copyValue)
+                return false;
+            try {
+                await navigator.clipboard.writeText(copyValue);
+                showAlert({
+                    message: t('ActionsMenu.copyToClipboard.success'),
+                    severity: 'success',
+                    variant: 'filled'
+                });
+                return true;
+            }
+            catch {
+                showAlert({
+                    message: t('ActionsMenu.copyToClipboard.error'),
+                    severity: 'error',
+                    variant: 'filled'
+                });
+                return false;
+            }
+        }
+    });
+};

package/dist/components/ActionsMenu/Actions/divider.d.ts

@@ -0,0 +1,2 @@
+import { Action } from '../types';
+export declare const divider: () => Action;

package/dist/components/ActionsMenu/Actions/divider.js

@@ -0,0 +1,7 @@
+import { Divider } from '@mui/material';
+import React, { forwardRef } from 'react';
+const DividerAction = forwardRef((_props, ref) => (React.createElement(Divider, { ref: ref, sx: { my: 1 } })));
+DividerAction.displayName = 'divider';
+export const divider = () => {
+    return { name: 'divider', Component: DividerAction };
+};

package/dist/components/ActionsMenu/Actions/download.d.ts

@@ -0,0 +1,15 @@
+import type { WebviewService } from 'cozy-intent';
+import { Action, ActionDocument } from '../types';
+export interface DownloadFileOptions<Client> {
+    client: Client;
+    file: ActionDocument;
+    url?: string;
+    webviewIntent?: WebviewService;
+    driveId?: string;
+}
+export interface DownloadActionOptions<Client> {
+    client: Client;
+    encryptedUrl?: string;
+    downloadFile: (options: DownloadFileOptions<Client>) => unknown;
+}
+export declare const download: <Client>({ client, encryptedUrl, downloadFile }: DownloadActionOptions<Client>) => Action;

package/dist/components/ActionsMenu/Actions/download.js

@@ -0,0 +1,18 @@
+import { Download } from '@linagora/twake-icons';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+export const download = ({ client, encryptedUrl, downloadFile }) => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'download',
+        label: t('ActionsMenu.download'),
+        icon: Download,
+        action: (docs, { webviewIntent, driveId }) => downloadFile({
+            client,
+            file: docs[0],
+            url: encryptedUrl,
+            webviewIntent,
+            driveId
+        })
+    });
+};

package/dist/components/ActionsMenu/Actions/editAttribute.d.ts

@@ -0,0 +1,2 @@
+import { Action } from '../types';
+export declare const editAttribute: () => Action;

package/dist/components/ActionsMenu/Actions/editAttribute.js

@@ -0,0 +1,12 @@
+import { TextInfo } from '@linagora/twake-icons';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+export const editAttribute = () => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'editAttribute',
+        label: t('ActionsMenu.editAttribute'),
+        icon: TextInfo,
+        action: (docs, { editAttributeCallback }) => editAttributeCallback(docs)
+    });
+};

package/dist/components/ActionsMenu/Actions/emailTo.d.ts

@@ -0,0 +1,2 @@
+import { Action } from '../types';
+export declare const emailTo: () => Action;

package/dist/components/ActionsMenu/Actions/emailTo.js

@@ -0,0 +1,16 @@
+import { Email } from '@linagora/twake-icons';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+export const emailTo = () => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'emailTo',
+        label: t('ActionsMenu.emailTo'),
+        icon: Email,
+        action: (docs) => {
+            const target = docs[0]?.email?.[0]?.address;
+            if (target)
+                window.open(`mailto:${target}`, '_self');
+        }
+    });
+};

package/dist/components/ActionsMenu/Actions/exportToText.d.ts

@@ -0,0 +1,6 @@
+import { Action, ActionDocument } from '../types';
+export interface ExportToTextActionOptions {
+    exportedText?: string;
+    file?: ActionDocument;
+}
+export declare const exportToText: ({ exportedText, file }: ExportToTextActionOptions) => Action;

package/dist/components/ActionsMenu/Actions/exportToText.js

@@ -0,0 +1,28 @@
+import { Export } from '@linagora/twake-icons';
+import { downloadBlob } from './helpers';
+import { logger } from './logger';
+import { makeAction } from './makeAction';
+import { makePdfBlobFromText } from './pdfHelpers';
+import { getActionsI18n } from '../locales';
+export const exportToText = ({ exportedText, file }) => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'exportToText',
+        label: t('ActionsMenu.exportToText'),
+        icon: Export,
+        displayCondition: () => !!exportedText,
+        action: async () => {
+            try {
+                const blob = await makePdfBlobFromText(exportedText ?? '');
+                const baseName = file?.name
+                    ? `${file.name.replace(/\.[^/.]+$/, '')}_export`
+                    : 'export';
+                return downloadBlob(blob, `${baseName}.pdf`);
+            }
+            catch (error) {
+                logger.error(error);
+                return false;
+            }
+        }
+    });
+};

package/dist/components/ActionsMenu/Actions/favorites.d.ts

@@ -0,0 +1,12 @@
+import { Action, ActionDocument, ShowAlert } from '../types';
+export interface FavoritesActionOptions {
+    client: {
+        save: (doc: ActionDocument) => Promise<unknown>;
+    };
+    showAlert: ShowAlert;
+    splitFilename: (doc: ActionDocument) => {
+        filename: string;
+    };
+}
+export declare const addToFavorites: (options: FavoritesActionOptions) => Action;
+export declare const removeFromFavorites: (options: FavoritesActionOptions) => Action;

package/dist/components/ActionsMenu/Actions/favorites.js

@@ -0,0 +1,44 @@
+import { Star, StarOutline } from '@linagora/twake-icons';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+const makeFavoriteAction = ({ favorite, client, showAlert, splitFilename }) => {
+    const { t } = getActionsI18n();
+    const scope = favorite ? 'add' : 'remove';
+    return makeAction({
+        name: favorite ? 'addToFavorites' : 'removeFromFavorites',
+        label: t(`ActionsMenu.favorites.${scope}.label`),
+        icon: favorite ? StarOutline : Star,
+        displayCondition: docs => docs.length > 0 &&
+            docs.every(doc => !!doc.cozyMetadata?.favorite !== favorite),
+        action: async (docs) => {
+            try {
+                for (const doc of docs) {
+                    await client.save({
+                        ...doc,
+                        cozyMetadata: { ...doc.cozyMetadata, favorite }
+                    });
+                }
+                const { filename } = splitFilename(docs[0]);
+                showAlert({
+                    message: t(`ActionsMenu.favorites.${scope}.success`, {
+                        filename,
+                        smart_count: docs.length
+                    }),
+                    severity: 'success'
+                });
+            }
+            catch {
+                showAlert({
+                    message: t('ActionsMenu.favorites.error'),
+                    severity: 'error'
+                });
+            }
+        }
+    });
+};
+export const addToFavorites = (options) => {
+    return makeFavoriteAction({ ...options, favorite: true });
+};
+export const removeFromFavorites = (options) => {
+    return makeFavoriteAction({ ...options, favorite: false });
+};

package/dist/components/ActionsMenu/Actions/helpers.d.ts

@@ -0,0 +1,24 @@
+import type { PDFDocument } from 'pdf-lib';
+import { ActionDocument, ActionFactory, ActionObject, GenerateWebLink, WebLinkClient } from '../types';
+/** Builds every action with the same options, skipping falsy entries */
+export declare const makeActions: <Options extends object>(actions?: (ActionFactory<Options> | false | null | undefined)[], options?: Options) => ActionObject[];
+export interface AppWebLinkOptions {
+    client: WebLinkClient;
+    generateWebLink: GenerateWebLink;
+    slug: string;
+    hash: string;
+}
+export declare const makeAppWebLink: ({ client, generateWebLink, slug, hash }: AppWebLinkOptions) => string;
+export declare const makeBase64FromFile: (file: Blob) => Promise<string | null>;
+export declare const fileToArrayBuffer: (file: Blob) => Promise<ArrayBuffer | Uint8Array>;
+/** Adds a PDF or an image file to the document, and returns its bytes */
+export declare const addFileToPdf: (pdfDoc: PDFDocument, file: Blob) => Promise<Uint8Array>;
+export type FetchBlobFileById<Client> = (client: Client, id: string) => Promise<Blob>;
+export interface MakePdfBlobOptions<Client> {
+    client: Client;
+    docs: ActionDocument[];
+    fetchBlobFileById: FetchBlobFileById<Client>;
+}
+/** Fetches the files of the docs and merges them into a single PDF */
+export declare const makePdfBlob: <Client>({ client, docs, fetchBlobFileById }: MakePdfBlobOptions<Client>) => Promise<Blob>;
+export declare const downloadBlob: (blob: Blob | null, filename: string) => boolean;

package/dist/components/ActionsMenu/Actions/helpers.js

@@ -0,0 +1,128 @@
+// Should guarantee good resolution for different uses (printing, downloading, etc.)
+const MAX_RESIZE_IMAGE_SIZE = 3840;
+const MAX_IMAGE_SIDE_SIZE = 1920;
+/** Builds every action with the same options, skipping falsy entries */
+export const makeActions = (actions = [], options) => {
+    // SAFETY: a factory that needs options reads them as its own contract
+    const factoryOptions = options ?? {};
+    return actions
+        .filter((actionFn) => !!actionFn)
+        .map(actionFn => {
+        const action = actionFn(factoryOptions);
+        const name = action.name || actionFn.name;
+        return { [name]: action };
+    });
+};
+export const makeAppWebLink = ({ client, generateWebLink, slug, hash }) => {
+    return generateWebLink({
+        slug,
+        cozyUrl: client.getStackClient().uri,
+        subDomainType: client.getInstanceOptions().subdomain,
+        pathname: '/',
+        hash
+    });
+};
+const readFileAs = (file, method) => {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onerror = reject;
+        reader.onload = () => resolve(reader.result);
+        reader[method](file);
+    });
+};
+export const makeBase64FromFile = async (file) => {
+    const result = await readFileAs(file, 'readAsDataURL');
+    return typeof result === 'string' ? result : null;
+};
+const computeImageScaleRatio = (image) => {
+    const longerSideSizeInPixel = Math.max(image.height, image.width);
+    return MAX_RESIZE_IMAGE_SIZE < longerSideSizeInPixel
+        ? MAX_RESIZE_IMAGE_SIZE / longerSideSizeInPixel
+        : 1;
+};
+const resizeImage = (fileDataUri) => {
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.src = fileDataUri;
+        image.onerror = reject;
+        image.onload = () => {
+            const canvas = document.createElement('canvas');
+            const scaleRatio = computeImageScaleRatio(image);
+            const scaledWidth = scaleRatio * image.width;
+            const scaledHeight = scaleRatio * image.height;
+            const quality = scaledWidth >= MAX_IMAGE_SIDE_SIZE ||
+                scaledHeight >= MAX_IMAGE_SIDE_SIZE
+                ? 0.35
+                : 0.75;
+            canvas.width = scaledWidth;
+            canvas.height = scaledHeight;
+            canvas.getContext('2d')?.drawImage(image, 0, 0, scaledWidth, scaledHeight);
+            resolve(canvas.toDataURL('image/jpeg', quality));
+        };
+    });
+};
+const addImageToPdf = async (pdfDoc, file) => {
+    const fileDataUri = await makeBase64FromFile(file);
+    if (fileDataUri === null)
+        throw new Error('Cannot read the image file');
+    const resizedImage = await resizeImage(fileDataUri);
+    const img = await pdfDoc.embedJpg(resizedImage);
+    const page = pdfDoc.addPage([img.width, img.height]);
+    const { width: pageWidth, height: pageHeight } = page.getSize();
+    page.drawImage(img, {
+        x: pageWidth / 2 - img.width / 2,
+        y: pageHeight / 2 - img.height / 2,
+        width: img.width,
+        height: img.height
+    });
+};
+export const fileToArrayBuffer = async (file) => {
+    if ('arrayBuffer' in file)
+        return await file.arrayBuffer();
+    const result = await readFileAs(file, 'readAsArrayBuffer');
+    if (!(result instanceof ArrayBuffer)) {
+        throw new Error('Cannot read the file');
+    }
+    return new Uint8Array(result);
+};
+const addPdfToPdf = async (pdfDoc, file) => {
+    const { PDFDocument } = await import('pdf-lib');
+    const pdfToAdd = await fileToArrayBuffer(file);
+    const document = await PDFDocument.load(pdfToAdd);
+    const copiedPages = await pdfDoc.copyPages(document, document.getPageIndices());
+    copiedPages.forEach(page => pdfDoc.addPage(page));
+};
+/** Adds a PDF or an image file to the document, and returns its bytes */
+export const addFileToPdf = async (pdfDoc, file) => {
+    if (file.type === 'application/pdf') {
+        await addPdfToPdf(pdfDoc, file);
+    }
+    else {
+        await addImageToPdf(pdfDoc, file);
+    }
+    return await pdfDoc.save();
+};
+/** Fetches the files of the docs and merges them into a single PDF */
+export const makePdfBlob = async ({ client, docs, fetchBlobFileById }) => {
+    const { PDFDocument } = await import('pdf-lib');
+    const pdfDoc = await PDFDocument.create();
+    for (const doc of docs) {
+        const blob = await fetchBlobFileById(client, doc._id);
+        await addFileToPdf(pdfDoc, blob);
+    }
+    const pdfBytes = await pdfDoc.save();
+    return new Blob([new Uint8Array(pdfBytes)], { type: 'application/pdf' });
+};
+export const downloadBlob = (blob, filename) => {
+    if (!blob || !filename)
+        return false;
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    a.style.display = 'none';
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    return true;
+};

package/dist/components/ActionsMenu/Actions/logger.d.ts

@@ -0,0 +1,3 @@
+export declare const logger: {
+    error: (...args: unknown[]) => void;
+};

package/dist/components/ActionsMenu/Actions/logger.js

@@ -0,0 +1,2 @@
+import minilog from 'cozy-minilog';
+export const logger = minilog('twake-mui/ActionsMenu');

package/dist/components/ActionsMenu/Actions/makeAction.d.ts

@@ -0,0 +1,11 @@
+import { Action, ActionComponent, ActionComponentSlotProps } from '../types';
+export interface MakeActionComponentOptions {
+    name: string;
+    label?: string;
+    icon?: Action['icon'];
+    componentProps?: ActionComponentSlotProps;
+}
+export declare const makeActionComponent: ({ name, label, icon, componentProps }: MakeActionComponentOptions) => ActionComponent;
+export type MakeActionOptions = Omit<Action, 'Component'> & Partial<Pick<Action, 'Component'>>;
+/** Makes an action, with a default `Component` when none is given */
+export declare const makeAction: ({ Component, ...action }: MakeActionOptions) => Action;

package/dist/components/ActionsMenu/Actions/makeAction.js

@@ -0,0 +1,19 @@
+import { Icon } from '@linagora/twake-icons';
+import { ListItemIcon } from '@mui/material';
+import React, { forwardRef } from 'react';
+import ListItemText from '../../ListItemText';
+import ActionsMenuItem from '../ActionsMenuItem';
+export const makeActionComponent = ({ name, label, icon, componentProps }) => {
+    const Component = forwardRef((props, ref) => (React.createElement(ActionsMenuItem, { ...props, ref: ref },
+        React.createElement(ListItemIcon, null, icon !== undefined && React.createElement(Icon, { ...componentProps?.Icon, icon: icon })),
+        React.createElement(ListItemText, { primary: label, ...componentProps?.ListItemText }))));
+    Component.displayName = name;
+    return Component;
+};
+/** Makes an action, with a default `Component` when none is given */
+export const makeAction = ({ Component, ...action }) => {
+    return {
+        ...action,
+        Component: Component ?? makeActionComponent(action)
+    };
+};

package/dist/components/ActionsMenu/Actions/modify.d.ts

@@ -0,0 +1,2 @@
+import { Action, WebLinkActionOptions } from '../types';
+export declare const modify: ({ client, generateWebLink }: WebLinkActionOptions) => Action;

package/dist/components/ActionsMenu/Actions/modify.js

@@ -0,0 +1,21 @@
+import { Pen } from '@linagora/twake-icons';
+import { makeAppWebLink } from './helpers';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+export const modify = ({ client, generateWebLink }) => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'modify',
+        label: t('ActionsMenu.modify'),
+        icon: Pen,
+        action: (docs) => {
+            const webLink = makeAppWebLink({
+                client,
+                generateWebLink,
+                slug: 'contacts',
+                hash: `/${docs[0]._id}/edit`
+            });
+            window.open(webLink, '_blank');
+        }
+    });
+};

package/dist/components/ActionsMenu/Actions/others.d.ts

@@ -0,0 +1,2 @@
+import { Action } from '../types';
+export declare const others: () => Action;

package/dist/components/ActionsMenu/Actions/others.js

@@ -0,0 +1,11 @@
+import { Dots } from '@linagora/twake-icons';
+import { makeAction } from './makeAction';
+import { getActionsI18n } from '../locales';
+export const others = () => {
+    const { t } = getActionsI18n();
+    return makeAction({
+        name: 'others',
+        label: t('ActionsMenu.others'),
+        icon: Dots
+    });
+};

package/dist/components/ActionsMenu/Actions/pdfHelpers.d.ts

@@ -0,0 +1,35 @@
+import type { PDFDocument, PDFFont, PDFPage } from 'pdf-lib';
+export interface WrapTextToLinesOptions {
+    font: PDFFont;
+    fontSize: number;
+    /** Max line width, in PDF units */
+    maxLineWidth: number;
+    line: string;
+}
+export declare const wrapTextToLines: ({ font, fontSize, maxLineWidth, line }: WrapTextToLinesOptions) => string[];
+export interface PdfCursor {
+    page: PDFPage;
+    y: number;
+}
+export interface PushNewPageIfNeededOptions extends PdfCursor {
+    pdfDoc: PDFDocument;
+    requiredHeight: number;
+    marginTop: number;
+    marginBottom: number;
+}
+export declare const pushNewPageIfNeeded: ({ pdfDoc, page, y, requiredHeight, marginTop, marginBottom }: PushNewPageIfNeededOptions) => PdfCursor;
+export interface DrawWrappedTextOptions extends PdfCursor {
+    pdfDoc: PDFDocument;
+    text: string;
+    font: PDFFont;
+    fontSize: number;
+    lineHeight: number;
+    marginX: number;
+    /** Top and bottom margin */
+    marginY: number;
+    /** Max line width, in PDF units */
+    maxLineWidth: number;
+}
+export declare const drawWrappedText: ({ pdfDoc, page, y, text, font, fontSize, lineHeight, marginX, marginY, maxLineWidth }: DrawWrappedTextOptions) => PdfCursor;
+/** Creates an A4 PDF from a plain text */
+export declare const makePdfBlobFromText: (text: string) => Promise<Blob>;

package/dist/components/ActionsMenu/Actions/pdfHelpers.js

@@ -0,0 +1,85 @@
+const A4_PAGE_SIZE = [595.28, 841.89];
+const TEXT_PDF_CONFIG = {
+    fontSize: 12,
+    lineHeight: 16,
+    marginX: 40,
+    marginY: 40,
+    pageSize: A4_PAGE_SIZE
+};
+export const wrapTextToLines = ({ font, fontSize, maxLineWidth, line }) => {
+    if (!line)
+        return [];
+    if (fontSize <= 0 || maxLineWidth <= 0)
+        return [line];
+    return line.split(' ').reduce((lines, word) => {
+        const currentLine = lines.at(-1);
+        if (currentLine === undefined)
+            return [word];
+        const testLine = `${currentLine} ${word}`;
+        if (font.widthOfTextAtSize(testLine, fontSize) <= maxLineWidth) {
+            lines[lines.length - 1] = testLine;
+        }
+        else {
+            lines.push(word);
+        }
+        return lines;
+    }, []);
+};
+export const pushNewPageIfNeeded = ({ pdfDoc, page, y, requiredHeight, marginTop, marginBottom }) => {
+    if (y - requiredHeight >= marginBottom)
+        return { page, y };
+    const { width, height } = page.getSize();
+    return {
+        page: pdfDoc.addPage([width, height]),
+        y: height - marginTop
+    };
+};
+export const drawWrappedText = ({ pdfDoc, page, y, text, font, fontSize, lineHeight, marginX, marginY, maxLineWidth }) => {
+    let cursor = { page, y };
+    for (const paragraph of text.split(/\r?\n/)) {
+        for (const line of wrapTextToLines({
+            font,
+            fontSize,
+            maxLineWidth,
+            line: paragraph
+        })) {
+            cursor = pushNewPageIfNeeded({
+                pdfDoc,
+                ...cursor,
+                requiredHeight: lineHeight,
+                marginTop: marginY,
+                marginBottom: marginY
+            });
+            cursor.page.drawText(line, {
+                x: marginX,
+                y: cursor.y - fontSize,
+                size: fontSize,
+                font
+            });
+            cursor = { ...cursor, y: cursor.y - lineHeight };
+        }
+        cursor = { ...cursor, y: cursor.y - lineHeight / 2 };
+    }
+    return cursor;
+};
+/** Creates an A4 PDF from a plain text */
+export const makePdfBlobFromText = async (text) => {
+    const { PDFDocument, StandardFonts } = await import('pdf-lib');
+    const pdfDoc = await PDFDocument.create();
+    const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+    const { fontSize, lineHeight, marginX, marginY, pageSize } = TEXT_PDF_CONFIG;
+    drawWrappedText({
+        pdfDoc,
+        page: pdfDoc.addPage(pageSize),
+        y: pageSize[1] - marginY,
+        text,
+        font,
+        fontSize,
+        lineHeight,
+        marginX,
+        marginY,
+        maxLineWidth: pageSize[0] - marginX * 2
+    });
+    const pdfBytes = await pdfDoc.save();
+    return new Blob([new Uint8Array(pdfBytes)], { type: 'application/pdf' });
+};

package/dist/components/ActionsMenu/Actions/print.d.ts

@@ -0,0 +1,13 @@
+import { FetchBlobFileById } from './helpers';
+import { Action, ActionDocument } from '../types';
+export interface PrintClient {
+    collection: (doctype: 'io.cozy.files') => {
+        getDownloadLinkById: (id: string, filename?: string) => Promise<string>;
+    };
+}
+export interface PrintActionOptions<Client extends PrintClient> {
+    client: Client;
+    fetchBlobFileById: FetchBlobFileById<Client>;
+    isFile: (doc: ActionDocument) => boolean;
+}
+export declare const print: <Client extends PrintClient>({ client, fetchBlobFileById, isFile }: PrintActionOptions<Client>) => Action;