@learnpack/learnpack 5.0.288 → 5.0.291

package/src/utils/configBuilder.ts

@@ -1,82 +1,100 @@
-import { Bucket, File } from "@google-cloud/storage"
-
-type TFile = {
-  name: string
-  slug: string
-  hidden: boolean
-}
-
-export type Exercise = {
-  title: string
-  slug: string
-  graded: boolean
-  files: TFile[]
-  translations: Record<string, string>
-  position: number
-}
-
-export type ConfigResponse = {
-  config: any
-  exercises: Exercise[]
-}
-
-/**
- * Crea la configuración y lista de ejercicios para un curso.
- *
- * @param bucket - Instancia de GCS Bucket donde está el curso.
- * @param courseSlug - Slug del curso a procesar.
- * @returns Promise con objeto { config, exercises } listo para usar.
- */
-export async function buildConfig(
-  bucket: Bucket,
-  courseSlug: string
-): Promise<ConfigResponse> {
-  const prefix = `courses/${courseSlug}/`
-  const [files] = await bucket.getFiles({ prefix })
-
-  // 1) Leer learn.json
-  const learnFile = files.find(f => f.name.endsWith("learn.json"))!
-  const [learnBuf] = await learnFile.download()
-  const learnJson = JSON.parse(learnBuf.toString())
-
-  // 2) Agrupar ejercicios
-  const map: Record<string, Omit<Exercise, "position">> = {}
-  for (const file of files) {
-    const parts = file.name.split("/")
-    if (!parts.includes("exercises")) continue
-
-    const slug = parts[parts.indexOf("exercises") + 1]
-    if (!map[slug]) {
-      map[slug] = {
-        title: slug,
-        slug,
-        graded: false,
-        files: [],
-        translations: {},
-      }
-    }
-
-    const fname = parts.pop()!
-    const m = fname.match(/^readme(?:\.([a-z]{2}))?\.md$/i)
-    if (m) {
-      const lang = m[1] || "en"
-      map[slug].translations[lang] = fname
-    } else {
-      map[slug].files.push({
-        name: fname,
-        slug: fname,
-        hidden: false,
-      })
-    }
-  }
-
-  const exercises = Object.values(map).map((ex, i) => ({
-    ...ex,
-    position: i,
-  }))
-
-  return {
-    config: { ...learnJson },
-    exercises,
-  }
-}
+import { Bucket, File } from "@google-cloud/storage"
+
+type TFile = {
+  name: string;
+  slug: string;
+  hidden: boolean;
+};
+
+export type Exercise = {
+  title: string;
+  slug: string;
+  graded: boolean;
+  files: TFile[];
+  translations: Record<string, string>;
+  position: number;
+};
+
+export type ConfigResponse = {
+  config: any;
+  exercises: Exercise[];
+};
+
+function naturalCompare(a: string, b: string): number {
+  // Split by dots and hyphens, compare numbers as numbers
+  const regex = /(\d+|\D+)/g
+  const ax = a.match(regex)!
+  const bx = b.match(regex)!
+  for (let i = 0; i < Math.max(ax.length, bx.length); i++) {
+    const an = parseInt(ax[i], 10)
+    const bn = parseInt(bx[i], 10)
+    if (!isNaN(an) && !isNaN(bn)) {
+      if (an !== bn) return an - bn
+    } else if (ax[i] !== bx[i]) return (ax[i] || "").localeCompare(bx[i] || "")
+  }
+
+  return 0
+}
+
+/**
+ * Crea la configuración y lista de ejercicios para un curso.
+ *
+ * @param bucket - Instancia de GCS Bucket donde está el curso.
+ * @param courseSlug - Slug del curso a procesar.
+ * @returns Promise con objeto { config, exercises } listo para usar.
+ */
+export async function buildConfig(
+  bucket: Bucket,
+  courseSlug: string
+): Promise<ConfigResponse> {
+  const prefix = `courses/${courseSlug}/`
+  const [files] = await bucket.getFiles({ prefix })
+
+  // 1) Leer learn.json
+  const learnFile = files.find(f => f.name.endsWith("learn.json"))!
+  const [learnBuf] = await learnFile.download()
+  const learnJson = JSON.parse(learnBuf.toString())
+
+  // 2) Agrupar ejercicios
+  const map: Record<string, Omit<Exercise, "position">> = {}
+  for (const file of files) {
+    const parts = file.name.split("/")
+    if (!parts.includes("exercises")) continue
+
+    const slug = parts[parts.indexOf("exercises") + 1]
+    if (!map[slug]) {
+      map[slug] = {
+        title: slug,
+        slug,
+        graded: false,
+        files: [],
+        translations: {},
+      }
+    }
+
+    const fname = parts.pop()!
+    const m = fname.match(/^readme(?:\.([a-z]{2}))?\.md$/i)
+    if (m) {
+      const lang = m[1] || "en"
+      map[slug].translations[lang] = fname
+    } else {
+      map[slug].files.push({
+        name: fname,
+        slug: fname,
+        hidden: false,
+      })
+    }
+  }
+
+  const exercises = Object.values(map)
+    .sort((a, b) => naturalCompare(a.slug, b.slug))
+    .map((ex, i) => ({
+      ...ex,
+      position: i,
+    }))
+
+  return {
+    config: { ...learnJson },
+    exercises,
+  }
+}

package/src/utils/export/index.ts

@@ -1,3 +1,4 @@
 export { exportToScorm } from "./scorm";
 export { exportToEpub } from "./epub";
+export { exportToZip } from "./zip";
 export { ExportFormat, ExportOptions, EpubMetadata } from "./types";

package/src/utils/export/types.ts

@@ -1,4 +1,4 @@
-export type ExportFormat = "scorm" | "epub";
+export type ExportFormat = "scorm" | "epub" | "zip";
 
 export interface ExportOptions {
   courseSlug: string;

package/src/utils/export/zip.ts

@@ -0,0 +1,55 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as archiver from "archiver";
+import * as mkdirp from "mkdirp";
+import * as rimraf from "rimraf";
+import { v4 as uuidv4 } from "uuid";
+import { ExportOptions } from "./types";
+import { downloadS3Folder, getCourseMetadata } from "./shared";
+
+export async function exportToZip(options: ExportOptions): Promise<string> {
+  const { courseSlug, bucket, outDir } = options;
+
+  // 1. Create temporary folder
+  const tmpName = uuidv4();
+  const zipOutDir = path.join(outDir, tmpName);
+  rimraf.sync(zipOutDir);
+  mkdirp.sync(zipOutDir);
+
+  // 2. Download all course files from bucket to temporary directory
+  await downloadS3Folder(bucket, `courses/${courseSlug}/`, zipOutDir);
+
+  // 3. Create ZIP file
+  const zipName = `${courseSlug}.zip`;
+  const zipPath = path.join(outDir, zipName);
+
+  // Remove existing zip file if it exists
+  if (fs.existsSync(zipPath)) {
+    fs.unlinkSync(zipPath);
+  }
+
+  const output = fs.createWriteStream(zipPath);
+  const archive = archiver("zip", { zlib: { level: 9 } });
+
+  return new Promise((resolve, reject) => {
+    output.on("close", () => {
+      console.log(`✅ ZIP export completed: ${archive.pointer()} total bytes`);
+      // Clean up temporary directory
+      rimraf.sync(zipOutDir);
+      resolve(zipPath);
+    });
+
+    archive.on("error", (err) => {
+      console.error("❌ ZIP creation error:", err);
+      rimraf.sync(zipOutDir);
+      reject(err);
+    });
+
+    archive.pipe(output);
+
+    // Add all files from the temporary directory to the ZIP
+    archive.directory(zipOutDir, false);
+
+    archive.finalize();
+  });
+}

package/src/creator/src/components/PassphraseValidator.tsx

@@ -1,47 +0,0 @@
-import React, { useEffect } from 'react';
-import { RIGOBOT_HOST } from '../utils/constants';
-
-interface PassphraseValidatorProps {
-  onSuccess?: (response: any) => void;
-  onError?: (error: any) => void;
-}
-
-const PassphraseValidator: React.FC<PassphraseValidatorProps> = ({ 
-  onSuccess, 
-  onError 
-}) => {
-  useEffect(() => {
-    const validatePassphrase = async () => {
-      try {
-        const response = await fetch(`${RIGOBOT_HOST}/v1/auth/public/token`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({
-            passphrase: 'bm29vnv4h43n'
-          })
-        });
-
-        const data = await response.json();
-        
-        if (response.ok) {
-          onSuccess?.(data);
-        } else {
-          onError?.(data);
-        }
-      } catch (error) {
-        onError?.(error);
-      }
-    };
-
-    validatePassphrase();
-  }, [onSuccess, onError]);
-
-  return (
-    <div>
-    </div>
-  );
-};
-
-export default PassphraseValidator;