@learnpack/learnpack 5.0.281 → 5.0.283

package/src/utils/export/epub.ts

@@ -13,7 +13,10 @@ const replaceQuestionsFromMarkdown = (markdown: string) => {
   // some text
   // ```
   const questionRegex = /```question([\s\S]*?)```/g;
-  return markdown.replace(questionRegex, "");
+  return markdown.replace(
+    questionRegex,
+    '<div type="text" class="open-question">Right your answer here</div>'
+  );
 };
 
 const replaceMermaidFromMarkdown = (markdown: string) => {
@@ -25,6 +28,13 @@ const replaceMermaidFromMarkdown = (markdown: string) => {
   return markdown.replace(mermaidRegex, "");
 };
 
+const cleanQuizOptions = (markdown: string) => {
+  // Remove [x] from quiz options, keeping only [ ] for all options
+  // This handles both - [x] and - [x] patterns
+  const quizRegex = /^(\s*-\s*)\[x\](\s+.*)$/gm;
+  return markdown.replace(quizRegex, "$1[ ]$2");
+};
+
 // Download cover image from bucket
 async function downloadCoverImage(
   bucket: any,
@@ -45,120 +55,9 @@ async function downloadCoverImage(
   }
 }
 
-// Convert markdown to HTML using pandoc
-async function convertMarkdownToHtml(
-  markdownPath: string,
-  outputPath: string,
-  learnAssetsDir?: string
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let stdout = "";
-    let stderr = "";
-
-    // Process markdown content to fix image paths
-    let markdownContent = fs.readFileSync(markdownPath, "utf-8");
-
-    if (learnAssetsDir && fs.existsSync(learnAssetsDir)) {
-      // Find all image references in markdown
-      const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
-      let match;
-      let imageCount = 0;
-
-      while ((match = imageRegex.exec(markdownContent)) !== null) {
-        const [fullMatch, altText, imagePath] = match;
-
-        // Check if it's a relative path starting with /learn/assets/
-        if (imagePath.startsWith("/.learn/assets/")) {
-          const imageName = path.basename(imagePath);
-          const absoluteImagePath = path.join(learnAssetsDir, imageName);
-
-          console.log(`📸 Looking for image: ${imageName}`);
-          console.log(`📁 Learn assets dir: ${learnAssetsDir}`);
-          console.log(`📁 Absolute path: ${absoluteImagePath}`);
-          console.log(`📁 Path exists: ${fs.existsSync(absoluteImagePath)}`);
-
-          if (fs.existsSync(absoluteImagePath)) {
-            // Use absolute path for the image
-            console.log(
-              `✅ Found image, replacing path: ${imagePath} -> ${absoluteImagePath}`
-            );
-            markdownContent = markdownContent.replace(
-              fullMatch,
-              `![${altText}](${absoluteImagePath})`
-            );
-            imageCount++;
-          } else {
-            console.log(`❌ Image not found: ${absoluteImagePath}`);
-            // List files in the assets directory for debugging
-            if (fs.existsSync(learnAssetsDir)) {
-              const files = fs.readdirSync(learnAssetsDir);
-              console.log(`📁 Files in assets directory: ${files.join(", ")}`);
-            } else {
-              console.log(
-                `❌ Assets directory does not exist: ${learnAssetsDir}`
-              );
-            }
-          }
-        }
-      }
-    }
-
-    markdownContent = replaceQuestionsFromMarkdown(markdownContent);
-    markdownContent = replaceMermaidFromMarkdown(markdownContent);
-
-    // Write processed markdown to a temporary file
-    const tempMarkdownPath = markdownPath + ".processed";
-    fs.writeFileSync(tempMarkdownPath, markdownContent, "utf-8");
-
-    const pandocArgs = [
-      tempMarkdownPath,
-      "-o",
-      outputPath,
-      "--from",
-      "markdown",
-      "--to",
-      "html",
-      "--standalone",
-      "--css",
-      path.join(__dirname, "../templates/epub/epub.css"),
-    ];
-
-    const pandoc = spawn("pandoc", pandocArgs);
-
-    pandoc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    pandoc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    pandoc.on("close", (code) => {
-      // Clean up temporary file
-      // if (fs.existsSync(tempMarkdownPath)) {
-      //   fs.unlinkSync(tempMarkdownPath);
-      // }
-
-      if (code === 0) {
-        console.log("Successfully converted:", markdownPath, "->", outputPath);
-        resolve();
-      } else {
-        const errorMessage = `Pandoc process exited with code ${code}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`;
-        console.error("Pandoc Error Details:", errorMessage);
-        reject(new Error(errorMessage));
-      }
-    });
-
-    pandoc.on("error", (err) => {
-      console.error("Pandoc spawn error:", err);
-      reject(err);
-    });
-  });
-}
-
-// Generate EPUB using pandoc
+// Generate EPUB using pandoc directly from markdown files
 async function generateEpub(
-  htmlFiles: string[],
+  markdownFiles: string[],
   outputPath: string,
   metadata: CourseMetadata,
   epubMetadata: EpubMetadata,
@@ -187,13 +86,13 @@ subject: "${metadata.technologies?.join(", ") || "Programming"}"
 
     fs.writeFileSync(yamlPath, yamlContent, "utf-8");
 
-    // Include all HTML files in the EPUB
+    // Include all markdown files in the EPUB
     const pandocArgs = [
-      ...htmlFiles, // All HTML files
+      ...markdownFiles, // All markdown files
       "-o",
       outputPath,
       "--from",
-      "html",
+      "markdown",
       "--to",
       "epub",
       "--metadata-file",
@@ -243,14 +142,14 @@ subject: "${metadata.technologies?.join(", ") || "Programming"}"
   });
 }
 
-// Process exercises and convert to HTML
+// Process exercises and collect markdown files for direct EPUB conversion
 async function processExercises(
   exercisesDir: string,
   outputDir: string,
   language: string = "en",
   learnAssetsDir?: string
 ): Promise<string[]> {
-  const htmlFiles: string[] = [];
+  const processedMarkdownFiles: string[] = [];
 
   console.log("Processing exercises directory:", exercisesDir);
   console.log("Output directory:", outputDir);
@@ -259,7 +158,7 @@ async function processExercises(
 
   if (!fs.existsSync(exercisesDir)) {
     console.log("Exercises directory does not exist:", exercisesDir);
-    return htmlFiles;
+    return processedMarkdownFiles;
   }
 
   console.log("Exercises directory exists, scanning for files...");
@@ -331,35 +230,47 @@ async function processExercises(
           }
         }
 
-        // Convert markdown to HTML
-        console.log("Converting markdown file:", relativeFilePath);
-        // const htmlFileName = entry.name.replace(/\.(md|markdown)$/, ".html");
-        const htmlPath = path.join(
+        // Process markdown content and save to output directory
+        console.log("Processing markdown file:", relativeFilePath);
+        const processedContent = processMarkdownContent(
+          fullPath,
+          learnAssetsDir
+        );
+
+        const processedMarkdownPath = path.join(
           outputDir,
-          relativeFilePath.replace(/\.(md|markdown)$/, ".html")
+          relativeFilePath.replace(/\.(md|markdown)$/, ".processed.md")
         );
 
-        console.log("HTML output path:", htmlPath);
-        mkdirp.sync(path.dirname(htmlPath));
-        // esling-disable-next-line
-        await convertMarkdownToHtml(fullPath, htmlPath, learnAssetsDir);
+        console.log("Processed markdown output path:", processedMarkdownPath);
+        mkdirp.sync(path.dirname(processedMarkdownPath));
+        fs.writeFileSync(processedMarkdownPath, processedContent, "utf-8");
 
-        htmlFiles.push(htmlPath);
+        processedMarkdownFiles.push(processedMarkdownPath);
         console.log(
-          "Successfully converted:",
+          "Successfully processed:",
           relativeFilePath,
           "->",
-          htmlPath
+          processedMarkdownPath
         );
       } else if (entry.name.endsWith(".html")) {
-        // Copy HTML files as-is
-        console.log("Copying HTML file:", relativeFilePath);
-        const destPath = path.join(outputDir, relativeFilePath);
-        mkdirp.sync(path.dirname(destPath));
-        // esling-disable-next-line
-        fs.copyFileSync(fullPath, destPath);
-        htmlFiles.push(destPath);
-        console.log("Successfully copied:", relativeFilePath, "->", destPath);
+        // Convert HTML files to markdown for consistency
+        console.log("Converting HTML file to markdown:", relativeFilePath);
+        const htmlContent = fs.readFileSync(fullPath, "utf-8");
+        const processedMarkdownPath = path.join(
+          outputDir,
+          relativeFilePath.replace(/\.html$/, ".processed.md")
+        );
+
+        mkdirp.sync(path.dirname(processedMarkdownPath));
+        fs.writeFileSync(processedMarkdownPath, htmlContent, "utf-8");
+        processedMarkdownFiles.push(processedMarkdownPath);
+        console.log(
+          "Successfully converted HTML:",
+          relativeFilePath,
+          "->",
+          processedMarkdownPath
+        );
       } else {
         console.log(
           "Skipping file:",
@@ -371,7 +282,64 @@ async function processExercises(
   };
 
   await processDirectory(exercisesDir);
-  return htmlFiles;
+  return processedMarkdownFiles;
+}
+
+// Process markdown content for EPUB conversion
+function processMarkdownContent(
+  markdownPath: string,
+  learnAssetsDir?: string
+): string {
+  let markdownContent = fs.readFileSync(markdownPath, "utf-8");
+
+  if (learnAssetsDir && fs.existsSync(learnAssetsDir)) {
+    // Find all image references in markdown
+    const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
+    let match;
+
+    while ((match = imageRegex.exec(markdownContent)) !== null) {
+      const [fullMatch, altText, imagePath] = match;
+
+      // Check if it's a relative path starting with /learn/assets/
+      if (imagePath.startsWith("/.learn/assets/")) {
+        const imageName = path.basename(imagePath);
+        const absoluteImagePath = path.join(learnAssetsDir, imageName);
+
+        console.log(`📸 Looking for image: ${imageName}`);
+        console.log(`📁 Learn assets dir: ${learnAssetsDir}`);
+        console.log(`📁 Absolute path: ${absoluteImagePath}`);
+        console.log(`📁 Path exists: ${fs.existsSync(absoluteImagePath)}`);
+
+        if (fs.existsSync(absoluteImagePath)) {
+          // Use absolute path for the image
+          console.log(
+            `✅ Found image, replacing path: ${imagePath} -> ${absoluteImagePath}`
+          );
+          markdownContent = markdownContent.replace(
+            fullMatch,
+            `![${altText}](${absoluteImagePath})`
+          );
+        } else {
+          console.log(`❌ Image not found: ${absoluteImagePath}`);
+          // List files in the assets directory for debugging
+          if (fs.existsSync(learnAssetsDir)) {
+            const files = fs.readdirSync(learnAssetsDir);
+            console.log(`📁 Files in assets directory: ${files.join(", ")}`);
+          } else {
+            console.log(
+              `❌ Assets directory does not exist: ${learnAssetsDir}`
+            );
+          }
+        }
+      }
+    }
+  }
+
+  markdownContent = replaceQuestionsFromMarkdown(markdownContent);
+  markdownContent = replaceMermaidFromMarkdown(markdownContent);
+  markdownContent = cleanQuizOptions(markdownContent);
+
+  return markdownContent;
 }
 
 const titlelify = (title: string) => {
@@ -392,71 +360,6 @@ function readSidebarData(learnDir: string): any {
   return null;
 }
 
-// Create EPUB table of contents
-function createTocHtml(
-  htmlFiles: string[],
-  metadata: CourseMetadata,
-  sidebarData: any,
-  language: string
-): string {
-  let tocContent = `
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="UTF-8">
-    <title>Table of Contents - ${metadata.title}</title>
-    <link rel="stylesheet" href="epub.css">
-</head>
-<body>
-    <h1>${metadata.title}</h1>
-    <nav id="toc">
-        <h2>Table of Contents</h2>
-        <ol>
-            <li><a href="main.html">Course Overview</a></li>
-`;
-
-  htmlFiles.forEach((file) => {
-    const fileName = path.basename(file, ".html");
-    const relativePath = fileName + ".html";
-
-    // Get the parent directory name (exercise slug) to look up in sidebar
-    const parentDir = path.basename(path.dirname(file));
-
-    // Try to get the title from sidebar.json using the parent directory name
-    let displayName = fileName;
-    if (sidebarData && sidebarData[parentDir]) {
-      console.log(
-        "🔍 Found title in sidebar.json:",
-        sidebarData[parentDir],
-        "; language: ",
-        language
-      );
-      // Get the title for the current language, fallback to English, then to the key itself
-      displayName =
-        sidebarData[parentDir][language] ||
-        sidebarData[parentDir]["en"] ||
-        titlelify(parentDir);
-    } else {
-      console.log(
-        "🔍 No title found in sidebar.json for parent directory:",
-        parentDir
-      );
-      // Fallback to titlelify if not found in sidebar
-      displayName = titlelify(parentDir);
-    }
-
-    tocContent += `            <li><a href="${relativePath}">${displayName}</a></li>\n`;
-  });
-
-  tocContent += `
-        </ol>
-    </nav>
-</body>
-</html>`;
-
-  return tocContent;
-}
-
 export async function exportToEpub(
   options: ExportOptions,
   epubMetadata: EpubMetadata
@@ -523,8 +426,8 @@ export async function exportToEpub(
 
   console.log("Course metadata:", metadata);
 
-  // 5. Process exercises and convert to HTML
-  console.log("🔄 Processing exercises and converting to HTML...");
+  // 5. Process exercises and prepare markdown files
+  console.log("🔄 Processing exercises and preparing markdown files...");
 
   // First, let's see what files were downloaded
   const exercisesPath = path.join(epubOutDir, "exercises");
@@ -545,9 +448,9 @@ export async function exportToEpub(
     console.log("❌ Exercises directory does not exist!");
   }
 
-  const htmlFiles = await processExercises(
+  const processedMarkdownFiles = await processExercises(
     path.join(epubOutDir, "exercises"),
-    path.join(epubOutDir, "html"),
+    path.join(epubOutDir, "processed"),
     language,
     path.join(epubOutDir, "learn", "assets")
   );
@@ -556,43 +459,57 @@ export async function exportToEpub(
   const sidebarData = readSidebarData(path.join(epubOutDir, "learn"));
   console.log("📋 Sidebar data loaded:", sidebarData ? "Success" : "Not found");
 
-  const tocHtml = createTocHtml(htmlFiles, metadata, sidebarData, language);
-  const tocPath = path.join(epubOutDir, "html", "toc.html");
-  mkdirp.sync(path.dirname(tocPath));
-  fs.writeFileSync(tocPath, tocHtml, "utf-8");
-
-  // 7. Create main content file
-  const mainContent = `
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="UTF-8">
-    <title>${metadata.title}</title>
-    <link rel="stylesheet" href="epub.css">
-</head>
-<body>
-    <h1>${metadata.title}</h1>
-    <p>${metadata.description || ""}</p>
-    <p><strong>Technologies:</strong> ${
-      metadata.technologies?.join(", ") || "Programming"
-    }</p>
-    <p><strong>Difficulty:</strong> ${metadata.difficulty}</p>
-    <p><strong>Language:</strong> ${language}</p>
-    <p><a href="toc.html">Go to Table of Contents</a></p>
-</body>
-</html>`;
-
-  const mainContentPath = path.join(epubOutDir, "html", "main.html");
+  // 7. Create main content file as markdown
+  const mainContent = `# ${metadata.title}
+
+${metadata.description || ""}
+
+**Technologies:** ${metadata.technologies?.join(", ") || "Programming"}
+
+**Difficulty:** ${metadata.difficulty}
+
+**Language:** ${language}
+
+---
+
+## Table of Contents
+
+${processedMarkdownFiles
+  .map((file, index) => {
+    const fileName = path.basename(file, ".processed.md");
+    const parentDir = path.basename(path.dirname(file));
+
+    // Get the title from sidebar.json using the parent directory name
+    let displayName = fileName;
+    if (sidebarData && sidebarData[parentDir]) {
+      displayName =
+        sidebarData[parentDir][language] ||
+        sidebarData[parentDir]["en"] ||
+        titlelify(parentDir);
+    } else {
+      displayName = titlelify(parentDir);
+    }
+
+    return `${index + 1}. ${displayName}`;
+  })
+  .join("\n")}
+
+---
+
+`;
+
+  const mainContentPath = path.join(epubOutDir, "processed", "main.md");
+  mkdirp.sync(path.dirname(mainContentPath));
   fs.writeFileSync(mainContentPath, mainContent, "utf-8");
 
-  // 8. Prepare all HTML files for EPUB generation
-  const allHtmlFiles = [mainContentPath, tocPath, ...htmlFiles];
+  // 8. Prepare all markdown files for EPUB generation
+  const allMarkdownFiles = [mainContentPath, ...processedMarkdownFiles];
 
   // 9. Generate EPUB using pandoc
   console.log("📖 Generating EPUB file...");
   const epubPath = path.join(epubOutDir, `${courseSlug}.epub`);
   await generateEpub(
-    allHtmlFiles,
+    allMarkdownFiles,
     epubPath,
     metadata,
     epubMetadata,
@@ -603,7 +520,7 @@ export async function exportToEpub(
 
   // Clean up temporary files
   console.log("Cleaning up temporary files...");
-  rimraf.sync(path.join(epubOutDir, "html"));
+  rimraf.sync(path.join(epubOutDir, "processed"));
   rimraf.sync(path.join(epubOutDir, "exercises"));
   rimraf.sync(path.join(epubOutDir, "learn"));