cozy-ui 135.5.0 → 135.6.0

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);
+  };
+}();