update

Author: omariosouto

.github/workflows/generate-download-files.yml

@@ -27,6 +27,9 @@ jobs:
         git config --global user.email ${{ env.COMMIT_EMAIL }}
         yarn install
         yarn scripts:create:shareable_guides
+        yarn scripts:create:shareable_guides_pdf
+
+
         echo "[END]"
         git add .
         git commit -m "docs: update downloadable files" || echo "Up to date with main"

_data/downloadFiles/PT_BR/agile.html

@@ -0,0 +1,78 @@
+// Function to group list items with checkboxes
+export function groupCheckboxListItems(html: string): string {
+  // Use regex to find <ul> blocks and process them
+  return html.replace(/<ul>([\s\S]*?)<\/ul>/g, (match, ulContent) => {
+    // Split the content by <li> tags
+    const listItems = ulContent.split(/(?=<li>)/);
+    let result = "<ul>";
+
+    for (let i = 0; i < listItems.length; i++) {
+      const item = listItems[i];
+      if (item.trim() === "") continue;
+
+      // Check if this <li> contains a checkbox
+      if (item.includes("<input") && item.includes('type="checkbox"')) {
+        // Find all subsequent non-checkbox items until the next checkbox
+        const nestedItems: string[] = [];
+        let j = i + 1;
+        while (j < listItems.length) {
+          const nextItem = listItems[j];
+          if (nextItem.trim() === "") {
+            j++;
+            continue;
+          }
+          // If we hit another checkbox, stop
+          if (
+            nextItem.includes("<input") &&
+            nextItem.includes('type="checkbox"')
+          ) {
+            break;
+          }
+          nestedItems.push(nextItem);
+          j++;
+        }
+
+        // Create the checkbox item with nested list
+        if (nestedItems.length > 0) {
+          // Remove the closing </li> from the checkbox item
+          const checkboxItem = item.replace(/<\/li>$/, "");
+          result += checkboxItem;
+          result += "<ul>";
+          result += nestedItems.join("");
+          result += "</ul></li>";
+          // Skip the items we've already processed
+          i = j - 1;
+        } else {
+          result += item;
+        }
+      } else {
+        // This is a regular list item, add it directly
+        result += item;
+      }
+    }
+
+    result += "</ul>";
+    return result;
+  });
+}
+
+// Function to wrap input tags with span for custom styling
+export function wrapInputTagsWithSpan(html: string): string {
+  return html.replace(
+    /(<input[^>]*type="checkbox"[^>]*>)/g,
+    '<span class="checkbox-wrapper">$1</span>'
+  );
+}
+
+// Main function to process HTML with all transformations
+export function processHtml(html: string): string {
+  let processedHtml = html;
+
+  // First wrap input tags with spans
+  processedHtml = wrapInputTagsWithSpan(processedHtml);
+
+  // Then group checkbox list items
+  processedHtml = groupCheckboxListItems(processedHtml);
+
+  return processedHtml;
+}

_data/downloadFiles/PT_BR/agile.pdf

@@ -0,0 +1,90 @@
+import { log } from "@scripts/modules/infra/log";
+import * as fs from "fs";
+import * as path from "path";
+import puppeteer from "puppeteer";
+import { parseMarkdownToHTML } from "./parseMarkdownToHTML";
+import { processHtml } from "./htmlProcessor";
+
+// Function to load HTML template
+function loadTemplate(): string {
+  const templatePath = path.join(__dirname, "template.html");
+  return fs.readFileSync(templatePath, "utf-8");
+}
+
+const main = async () => {
+  try {
+    log("Starting PDF generation for Agile guide...");
+
+    // Read the markdown file
+    const markdownPath = path.join(
+      process.cwd(),
+      "_data",
+      "downloadFiles",
+      "PT_BR",
+      "agile.md"
+    );
+    log(`Reading markdown file from: ${markdownPath}`);
+
+    if (!fs.existsSync(markdownPath)) {
+      throw new Error(`Markdown file not found: ${markdownPath}`);
+    }
+
+    const markdownContent = fs.readFileSync(markdownPath, "utf-8");
+    log("Markdown file read successfully");
+
+    // Convert markdown to HTML using the parseMarkdownToHTML function
+    const htmlContent = parseMarkdownToHTML({ markdown: markdownContent });
+
+    // Process HTML with custom transformations
+    const styledHtmlContent = processHtml(htmlContent);
+    log("Markdown converted to HTML");
+
+    // Load template and create the complete HTML document
+    const template = loadTemplate();
+    const completeHtml = template
+      .replace("{{content}}", styledHtmlContent)
+      .replace("{{date}}", new Date().toLocaleDateString("pt-BR"));
+
+    // Get the directory where the markdown file is located
+    const markdownDir = path.dirname(markdownPath);
+
+    // Save HTML file for debugging
+    const htmlPath = path.join(markdownDir, "agile.html");
+    fs.writeFileSync(htmlPath, completeHtml);
+    log(`HTML file saved to: ${htmlPath}`);
+
+    // Generate PDF using Puppeteer
+    log("Launching Puppeteer...");
+    const browser = await puppeteer.launch({
+      headless: true,
+      args: ["--no-sandbox", "--disable-setuid-sandbox"],
+    });
+
+    const page = await browser.newPage();
+
+    // Set content and wait for rendering
+    await page.setContent(completeHtml, { waitUntil: "networkidle0" });
+
+    // Generate PDF in the same directory as the markdown file
+    const pdfPath = path.join(markdownDir, "agile.pdf");
+    await page.pdf({
+      path: pdfPath,
+      format: "A4",
+      margin: {
+        top: "20mm",
+        right: "20mm",
+        bottom: "20mm",
+        left: "20mm",
+      },
+      printBackground: true,
+    });
+
+    await browser.close();
+    log(`PDF generated successfully: ${pdfPath}`);
+  } catch (error) {
+    log(`Error generating PDF: ${error}`);
+    process.exit(1);
+  }
+};
+
+main();

_scripts/modules/shareable_guides_pdf/htmlProcessor.ts

@@ -0,0 +1,25 @@
+import { marked } from "marked";
+
+interface parseMarkdownToHTMLParams {
+  markdown: string;
+  singleLine?: boolean;
+}
+export function parseMarkdownToHTML({
+  markdown,
+  singleLine = false,
+}: parseMarkdownToHTMLParams) {
+  const html = marked(trimLines(markdown), {
+    async: false,
+  });
+  const hasOnlyOneParagraph = html.match(/<p>/g)?.length === 1;
+
+  if (singleLine && hasOnlyOneParagraph) {
+    return html?.replace(/<p>|<\/p>/g, "").trim();
+  }
+
+  return html.trim();
+}
+
+function trimLines(str: string) {
+  return str?.replace(/^ +/gm, "");
+}