cozy-ui 135.5.0 → 135.7.0

package/transpiled/react/ActionsMenu/Actions/exportToText.js

@@ -0,0 +1,84 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _extends from "@babel/runtime/helpers/extends";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import React, { forwardRef } from 'react';
+import logger from 'cozy-logger';
+import { downloadBlob } from "cozy-ui/transpiled/react/ActionsMenu/Actions/helpers";
+import { getActionsI18n } from "cozy-ui/transpiled/react/ActionsMenu/Actions/locales/withActionsLocales";
+import { makePdfBlobFromText } from "cozy-ui/transpiled/react/ActionsMenu/Actions/pdfHelpers";
+import Icon from "cozy-ui/transpiled/react/Icon";
+import ExportIcon from "cozy-ui/transpiled/react/Icons/Export";
+import ListItemIcon from "cozy-ui/transpiled/react/ListItemIcon";
+import ListItemText from "cozy-ui/transpiled/react/ListItemText";
+import ActionsMenuItem from "cozy-ui/transpiled/react/ActionsMenu/ActionsMenuItem";
+
+var makeComponent = function makeComponent(label, icon) {
+  var Component = /*#__PURE__*/forwardRef(function (props, ref) {
+    return /*#__PURE__*/React.createElement(ActionsMenuItem, _extends({}, props, {
+      ref: ref
+    }), /*#__PURE__*/React.createElement(ListItemIcon, null, /*#__PURE__*/React.createElement(Icon, {
+      icon: icon
+    })), /*#__PURE__*/React.createElement(ListItemText, {
+      primary: label
+    }));
+  });
+  Component.displayName = 'exportToText';
+  return Component;
+};
+
+export var exportToText = function exportToText(_ref) {
+  var exportedText = _ref.exportedText,
+      file = _ref.file;
+
+  var _getActionsI18n = getActionsI18n(),
+      t = _getActionsI18n.t;
+
+  var icon = ExportIcon;
+  var label = t('exportToText');
+  return {
+    name: 'exportToText',
+    icon: icon,
+    label: label,
+    displayCondition: function displayCondition() {
+      return !!exportedText;
+    },
+    Component: makeComponent(label, icon),
+    action: function () {
+      var _action = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var blob, baseName;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.prev = 0;
+                _context.next = 3;
+                return makePdfBlobFromText(exportedText);
+
+              case 3:
+                blob = _context.sent;
+                baseName = file !== null && file !== void 0 && file.name ? "".concat(file.name.replace(/\.[^/.]+$/, ''), "_export") : 'export';
+                downloadBlob(blob, "".concat(baseName, ".pdf"));
+                _context.next = 11;
+                break;
+
+              case 8:
+                _context.prev = 8;
+                _context.t0 = _context["catch"](0);
+                logger.error(_context.t0);
+
+              case 11:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[0, 8]]);
+      }));
+
+      function action() {
+        return _action.apply(this, arguments);
+      }
+
+      return action;
+    }()
+  };
+};

package/transpiled/react/ActionsMenu/Actions/helpers.d.ts

@@ -5,4 +5,5 @@ export function makeBase64FromFile(file: File): Promise<string | null>;
 export function fileToArrayBuffer(file: File): Promise<ArrayBuffer>;
 export function addFileToPdf(pdfDoc: PDFDocument, file: File): Promise<ArrayBuffer>;
 export function makePdfBlob({ client, docs, fetchBlobFileById }: object): Promise<object>;
+export function downloadBlob(blob: Blob, filename: string): void;
 import { PDFDocument } from "pdf-lib/cjs/api";

package/transpiled/react/ActionsMenu/Actions/helpers.js

@@ -475,4 +475,23 @@ export var makePdfBlob = /*#__PURE__*/function () {
   return function makePdfBlob(_x11) {
     return _ref11.apply(this, arguments);
   };
-}();
+}();
+/**
+ * Trigger a browser download for a given blob.
+ *
+ * @param {Blob} blob - File content
+ * @param {string} filename - Desired filename
+ * @returns {void}
+ */
+
+export var downloadBlob = function downloadBlob(blob, filename) {
+  if (!blob || !filename) return;
+  var url = URL.createObjectURL(blob);
+  var a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  a.style.display = 'none';
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+};

package/transpiled/react/ActionsMenu/Actions/index.d.ts

@@ -13,3 +13,4 @@ export { viewInDrive } from "./viewInDrive";
 export { copyToClipboard } from "./copyToClipboard";
 export { editAttribute } from "./editAttribute";
 export { others } from "./others";
+export { exportToText } from "./exportToText";

package/transpiled/react/ActionsMenu/Actions/index.js

@@ -12,4 +12,5 @@ export { viewInContacts } from './viewInContacts';
 export { viewInDrive } from './viewInDrive';
 export { copyToClipboard } from './copyToClipboard';
 export { editAttribute } from './editAttribute';
-export { others } from './others';
+export { others } from './others';
+export { exportToText } from './exportToText';

package/transpiled/react/ActionsMenu/Actions/locales/withActionsLocales.js

@@ -26,7 +26,8 @@ var en = {
     success: "Copied to clipboard",
     error: "Cannot copy to clipboard"
   },
-  call: "Call"
+  call: "Call",
+  exportToText: "Export as text"
 };
 var fr = {
   menu: "Menu",
@@ -55,7 +56,8 @@ var fr = {
     success: "Copi\xE9 dans le presse-papier",
     error: "Impossible de copier dans le presse-papier"
   },
-  call: "Appeler"
+  call: "Appeler",
+  exportToText: "Exporter en texte"
 };
 var ru = {
   menu: "\u041C\u0435\u043D\u044E",
@@ -84,7 +86,8 @@ var ru = {
     success: "\u0421\u043A\u043E\u043F\u0438\u0440\u043E\u0432\u0430\u043D\u043E \u0432 \u0431\u0443\u0444\u0435\u0440 \u043E\u0431\u043C\u0435\u043D\u0430",
     error: "\u041D\u0435 \u0443\u0434\u0430\u0435\u0442\u0441\u044F \u0441\u043A\u043E\u043F\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0432 \u0431\u0443\u0444\u0435\u0440 \u043E\u0431\u043C\u0435\u043D\u0430"
   },
-  call: "\u0417\u0432\u043E\u043D\u0438\u0442\u044C"
+  call: "\u0417\u0432\u043E\u043D\u0438\u0442\u044C",
+  exportToText: "\u042D\u043A\u0441\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043A\u0430\u043A \u0442\u0435\u043A\u0441\u0442"
 };
 var vi = {
   menu: "Menu",
@@ -113,7 +116,8 @@ var vi = {
     success: "\u0110\xE3 sao ch\xE9p v\xE0o clipboard",
     error: "Kh\xF4ng th\u1EC3 sao ch\xE9p v\xE0o clipboard"
   },
-  call: "G\u1ECDi"
+  call: "G\u1ECDi",
+  exportToText: "Xu\u1EA5t d\u01B0\u1EDBi d\u1EA1ng v\u0103n b\u1EA3n"
 };
 export var locales = {
   en: en,

package/transpiled/react/ActionsMenu/Actions/pdfHelpers.d.ts

@@ -0,0 +1,34 @@
+export function wrapTextToLines({ font, fontSize, maxLineWidth, line }: {
+    font: import('pdf-lib').PDFFont;
+    fontSize: number;
+    maxLineWidth: number;
+    line: string;
+}): string[];
+export function pushNewPageIfNeeded({ pdfDoc, page, y, requiredHeight, marginTop, marginBottom }: {
+    pdfDoc: PDFDocument;
+    page: import('pdf-lib').PDFPage;
+    y: number;
+    requiredHeight: number;
+    marginTop: number;
+    marginBottom: number;
+}): {
+    page: import('pdf-lib').PDFPage;
+    y: number;
+};
+export function drawWrappedText({ pdfDoc, page, y, text, font, fontSize, lineHeight, marginX, marginY, maxLineWidth }: {
+    pdfDoc: PDFDocument;
+    page: import('pdf-lib').PDFPage;
+    y: number;
+    text: string;
+    font: import('pdf-lib').PDFFont;
+    fontSize: number;
+    lineHeight: number;
+    marginX: number;
+    marginY: number;
+    maxLineWidth: number;
+}): {
+    page: import('pdf-lib').PDFPage;
+    y: number;
+};
+export function makePdfBlobFromText(text: string): Promise<Blob>;
+import { PDFDocument } from "pdf-lib/cjs/api";

package/transpiled/react/ActionsMenu/Actions/pdfHelpers.js

@@ -0,0 +1,242 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { PDFDocument, StandardFonts } from 'pdf-lib';
+/**
+ * Wrap a string into multiple lines based on available width.
+ *
+ * @param {object} opts
+ * @param {import('pdf-lib').PDFFont} opts.font - Embedded pdf-lib font
+ * @param {number} opts.fontSize - Font size
+ * @param {number} opts.maxLineWidth - Max line width in PDF units
+ * @param {string} opts.line - Text to wrap
+ * @returns {string[]} Wrapped lines
+ */
+
+export var wrapTextToLines = function wrapTextToLines(_ref) {
+  var font = _ref.font,
+      fontSize = _ref.fontSize,
+      maxLineWidth = _ref.maxLineWidth,
+      line = _ref.line;
+  if (!line) return [];
+  if (fontSize <= 0 || maxLineWidth <= 0) return [line];
+  var words = line.split(' ');
+  return words.reduce(function (lines, word) {
+    var currentLine = lines[lines.length - 1];
+
+    if (!currentLine) {
+      return [word];
+    }
+
+    var testLine = "".concat(currentLine, " ").concat(word);
+    var testWidth = font.widthOfTextAtSize(testLine, fontSize);
+
+    if (testWidth <= maxLineWidth) {
+      lines[lines.length - 1] = testLine;
+    } else {
+      lines.push(word);
+    }
+
+    return lines;
+  }, []);
+};
+/**
+ * Add a new page if there is not enough space to draw a new line.
+ *
+ * @param {object} opts
+ * @param {PDFDocument} opts.pdfDoc - pdf-lib document
+ * @param {import('pdf-lib').PDFPage} opts.page - Current page
+ * @param {number} opts.y - Current y cursor position
+ * @param {number} opts.requiredHeight - Height required before adding a new page
+ * @param {number} opts.marginTop - Top margin
+ * @param {number} opts.marginBottom - Bottom margin
+ * @returns {{ page: import('pdf-lib').PDFPage, y: number }} Updated page and y
+ */
+
+export var pushNewPageIfNeeded = function pushNewPageIfNeeded(_ref2) {
+  var pdfDoc = _ref2.pdfDoc,
+      page = _ref2.page,
+      y = _ref2.y,
+      requiredHeight = _ref2.requiredHeight,
+      marginTop = _ref2.marginTop,
+      marginBottom = _ref2.marginBottom;
+
+  if (!pdfDoc || !page) {
+    throw new Error('pdfDoc and page are required');
+  }
+
+  var _page$getSize = page.getSize(),
+      width = _page$getSize.width,
+      height = _page$getSize.height;
+
+  if (y - requiredHeight < marginBottom) {
+    var newPage = pdfDoc.addPage([width, height]);
+    return {
+      page: newPage,
+      y: height - marginTop
+    };
+  }
+
+  return {
+    page: page,
+    y: y
+  };
+};
+/**
+ * Draws a plain text string onto a PDF, wrapping lines to max width and handling page breaks.
+ *
+ * @param {object} opts
+ * @param {PDFDocument} opts.pdfDoc - pdf-lib document
+ * @param {import('pdf-lib').PDFPage} opts.page - Current page
+ * @param {number} opts.y - Current y cursor position
+ * @param {string} opts.text - Text to draw
+ * @param {import('pdf-lib').PDFFont} opts.font - Embedded pdf-lib font
+ * @param {number} opts.fontSize - Font size
+ * @param {number} opts.lineHeight - Line height
+ * @param {number} opts.marginX - Left margin
+ * @param {number} opts.marginY - Top/bottom margin
+ * @param {number} opts.maxLineWidth - Max line width in PDF units
+ * @returns {{ page: import('pdf-lib').PDFPage, y: number }} Updated page and y
+ */
+
+export var drawWrappedText = function drawWrappedText(_ref3) {
+  var pdfDoc = _ref3.pdfDoc,
+      page = _ref3.page,
+      y = _ref3.y,
+      text = _ref3.text,
+      font = _ref3.font,
+      fontSize = _ref3.fontSize,
+      lineHeight = _ref3.lineHeight,
+      marginX = _ref3.marginX,
+      marginY = _ref3.marginY,
+      maxLineWidth = _ref3.maxLineWidth;
+  var currentPage = page;
+  var currentY = y;
+  var paragraphs = String(text !== null && text !== void 0 ? text : '').split(/\r?\n/);
+  var renderItems = paragraphs.flatMap(function (paragraph) {
+    var wrappedLines = wrapTextToLines({
+      font: font,
+      fontSize: fontSize,
+      maxLineWidth: maxLineWidth,
+      line: paragraph
+    });
+    return [].concat(_toConsumableArray(wrappedLines), [{
+      type: 'paragraphGap'
+    }]);
+  });
+
+  var _iterator = _createForOfIteratorHelper(renderItems),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+
+      if (typeof item === 'object' && item.type === 'paragraphGap') {
+        currentY -= lineHeight / 2;
+        continue;
+      }
+
+      var nextState = pushNewPageIfNeeded({
+        pdfDoc: pdfDoc,
+        page: currentPage,
+        y: currentY,
+        requiredHeight: lineHeight,
+        marginTop: marginY,
+        marginBottom: marginY
+      });
+      currentPage = nextState.page;
+      currentY = nextState.y;
+      currentPage.drawText(item, {
+        x: marginX,
+        y: currentY - fontSize,
+        size: fontSize,
+        font: font
+      });
+      currentY -= lineHeight;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return {
+    page: currentPage,
+    y: currentY
+  };
+};
+/**
+ * Creates a PDF Blob from a plain text string.
+ *
+ * @param {string} text - Text content to put into the PDF
+ * @returns {Promise<Blob>} PDF file as a Blob
+ */
+
+export var makePdfBlobFromText = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(text) {
+    var pdfDoc, font, CONFIG, maxLineWidth, initialPage, pdfBytes;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return PDFDocument.create();
+
+          case 2:
+            pdfDoc = _context.sent;
+            _context.next = 5;
+            return pdfDoc.embedFont(StandardFonts.Helvetica);
+
+          case 5:
+            font = _context.sent;
+            CONFIG = {
+              fontSize: 12,
+              lineHeight: 16,
+              marginX: 40,
+              marginY: 40,
+              pageSize: [595.28, 841.89] // A4
+
+            };
+            maxLineWidth = CONFIG.pageSize[0] - CONFIG.marginX * 2;
+            initialPage = pdfDoc.addPage(CONFIG.pageSize);
+            drawWrappedText({
+              pdfDoc: pdfDoc,
+              page: initialPage,
+              y: CONFIG.pageSize[1] - CONFIG.marginY,
+              text: text,
+              font: font,
+              fontSize: CONFIG.fontSize,
+              lineHeight: CONFIG.lineHeight,
+              marginX: CONFIG.marginX,
+              marginY: CONFIG.marginY,
+              maxLineWidth: maxLineWidth
+            });
+            _context.next = 12;
+            return pdfDoc.save();
+
+          case 12:
+            pdfBytes = _context.sent;
+            return _context.abrupt("return", new Blob([pdfBytes], {
+              type: 'application/pdf'
+            }));
+
+          case 14:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function makePdfBlobFromText(_x) {
+    return _ref4.apply(this, arguments);
+  };
+}();