@learnpack/learnpack 5.0.276 → 5.0.278

package/src/utils/export/scorm.ts

@@ -0,0 +1,121 @@
+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, CourseMetadata } from "./types";
+import {
+  copyDir,
+  downloadS3Folder,
+  getFilesList,
+  getCourseMetadata,
+} from "./shared";
+
+export async function exportToScorm(options: ExportOptions): Promise<string> {
+  const { courseSlug, bucket, outDir } = options;
+
+  // 1. Create temporary folder
+  const tmpName = uuidv4();
+  const scormOutDir = path.join(outDir, tmpName);
+  rimraf.sync(scormOutDir);
+  mkdirp.sync(scormOutDir);
+
+  // 2. Copy SCORM template
+  const scormTpl = path.join(__dirname, "../templates/scorm");
+  copyDir(scormTpl, scormOutDir);
+
+  // Paths
+  const appDir = path.resolve(__dirname, "../../ui/_app");
+  const configDir = path.join(scormOutDir, "config");
+
+  // Check if _app exists and has content
+  if (fs.existsSync(appDir) && fs.readdirSync(appDir).length > 0) {
+    // Copy app.css and app.js to config/
+    for (const file of ["app.css", "app.js"]) {
+      const src = path.join(appDir, file);
+      const dest = path.join(configDir, file);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+      }
+    }
+
+    // Copy logo-192.png and logo-512.png to SCORM build root
+    for (const file of ["logo-192.png", "logo-512.png"]) {
+      const src = path.join(appDir, file);
+      const dest = path.join(scormOutDir, file);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+      }
+    }
+  }
+
+  // 3. Download exercises and .learn from bucket
+  await downloadS3Folder(
+    bucket,
+    `courses/${courseSlug}/exercises/`,
+    path.join(scormOutDir, "exercises")
+  );
+  await downloadS3Folder(
+    bucket,
+    `courses/${courseSlug}/.learn/`,
+    path.join(scormOutDir, ".learn")
+  );
+
+  // 4. Read learn.json for course info
+  const learnJson = await getCourseMetadata(bucket, courseSlug);
+
+  // 5. Replace imsmanifest.xml
+  const manifestPath = path.join(scormOutDir, "imsmanifest.xml");
+  let manifest = fs.readFileSync(manifestPath, "utf-8");
+  manifest = manifest.replace(/{{organization_name}}/g, "FourGeeksAcademy");
+  manifest = manifest.replace(
+    /{{course_title}}/g,
+    learnJson.title?.en || learnJson.title || courseSlug
+  );
+
+  // Generate exercises list
+  const exercisesList = getFilesList(
+    path.join(scormOutDir, "exercises"),
+    "exercises"
+  ).join("\n      ");
+  manifest = manifest.replace(/{{exercises_list}}/g, exercisesList);
+
+  // Generate images list (optional, if you have assets)
+  let imagesList = "";
+  const assetsDir = path.join(scormOutDir, ".learn", "assets");
+  if (fs.existsSync(assetsDir)) {
+    imagesList = getFilesList(assetsDir, ".learn/assets").join("\n      ");
+  }
+  manifest = manifest.replace(/{{images_list}}/g, imagesList);
+
+  fs.writeFileSync(manifestPath, manifest, "utf-8");
+
+  // 6. Replace title in config/index.html
+  const configIndexPath = path.join(scormOutDir, "config", "index.html");
+  let indexHtml = fs.readFileSync(configIndexPath, "utf-8");
+  indexHtml = indexHtml.replace(
+    /{{title}}/g,
+    learnJson.title?.en || learnJson.title || courseSlug
+  );
+  fs.writeFileSync(configIndexPath, indexHtml, "utf-8");
+
+  // 7. Compress as ZIP
+  const zipPath = `${scormOutDir}.zip`;
+  await new Promise((resolve: any, reject: any) => {
+    const output = fs.createWriteStream(zipPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+
+    output.on("close", resolve);
+    archive.on("error", reject);
+
+    archive.pipe(output);
+    archive.directory(scormOutDir, false);
+    archive.finalize();
+  });
+
+  // Clean up temporary directory
+  rimraf.sync(scormOutDir);
+
+  return zipPath;
+}

package/src/utils/export/shared.ts

@@ -0,0 +1,61 @@
+import * as path from "path";
+import * as fs from "fs";
+import * as mkdirp from "mkdirp";
+
+// Utility function to copy directory recursively
+export function copyDir(src: string, dest: string) {
+  if (!fs.existsSync(dest)) mkdirp.sync(dest);
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// Download all files from a GCS Bucket prefix to a local folder
+export async function downloadS3Folder(
+  bucket: any,
+  prefix: string,
+  localPath: string
+) {
+  const [files] = await bucket.getFiles({ prefix });
+  for (const file of files) {
+    const relPath = file.name.replace(prefix, "");
+    if (!relPath) continue;
+    const outPath = path.join(localPath, relPath);
+    mkdirp.sync(path.dirname(outPath));
+    // esling-disable-next-line
+    const [buf] = await file.download();
+    fs.writeFileSync(outPath, buf);
+  }
+}
+
+// Generate file list for manifest, given a folder
+export function getFilesList(folder: string, base: string) {
+  let list: string[] = [];
+  const files = fs.readdirSync(folder, { withFileTypes: true });
+  for (const file of files) {
+    const filePath = path.join(folder, file.name);
+    if (file.isDirectory()) {
+      // esling-disable-next-line
+      list = list.concat(getFilesList(filePath, path.join(base, file.name)));
+    } else {
+      list.push(
+        `<file href="${path.join(base, file.name).replace(/\\/g, "/")}" />`
+      );
+    }
+  }
+  return list;
+}
+
+// Read course metadata from learn.json
+export async function getCourseMetadata(bucket: any, courseSlug: string) {
+  const [learnBuf] = await bucket
+    .file(`courses/${courseSlug}/learn.json`)
+    .download();
+  return JSON.parse(learnBuf.toString());
+}

package/src/utils/export/types.ts

@@ -0,0 +1,25 @@
+export type ExportFormat = "scorm" | "epub";
+
+export interface ExportOptions {
+  courseSlug: string;
+  format: ExportFormat;
+  bucket: any; // Google Cloud Storage Bucket
+  outDir: string;
+  language?: string; // Optional language parameter for EPUB export
+}
+
+export interface EpubMetadata {
+  creator: string;
+  publisher: string;
+  title: string;
+  rights: string;
+  lang: string;
+}
+
+export interface CourseMetadata {
+  title: string;
+  description?: string;
+  language?: string;
+  technologies?: string[];
+  difficulty?: string;
+}

package/src/utils/templates/epub/epub.css

@@ -0,0 +1,133 @@
+/* Basic EPUB styling */
+body {
+  font-family: "Georgia", serif;
+  line-height: 1.6;
+  margin: 2em;
+  color: #333;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  color: #2c3e50;
+  margin-top: 1.5em;
+  margin-bottom: 0.5em;
+}
+
+h1 {
+  font-size: 2em;
+  border-bottom: 2px solid #3498db;
+  padding-bottom: 0.3em;
+}
+
+h2 {
+  font-size: 1.5em;
+  border-bottom: 1px solid #bdc3c7;
+  padding-bottom: 0.2em;
+}
+
+p {
+  margin-bottom: 1em;
+  text-align: justify;
+}
+
+code {
+  background-color: #f8f9fa;
+  padding: 0.2em 0.4em;
+  border-radius: 3px;
+  font-family: "Courier New", monospace;
+  font-size: 0.9em;
+}
+
+pre {
+  background-color: #f8f9fa;
+  padding: 1em;
+  border-radius: 5px;
+  overflow-x: auto;
+  border-left: 4px solid #3498db;
+}
+
+pre code {
+  background-color: transparent;
+  padding: 0;
+}
+
+blockquote {
+  border-left: 4px solid #bdc3c7;
+  margin: 1em 0;
+  padding-left: 1em;
+  font-style: italic;
+  color: #7f8c8d;
+}
+
+ul,
+ol {
+  margin-bottom: 1em;
+  padding-left: 2em;
+}
+
+li {
+  margin-bottom: 0.5em;
+}
+
+a {
+  color: #3498db;
+  text-decoration: none;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+img {
+  max-width: 100%;
+  height: auto;
+  display: block;
+  margin: 1em auto;
+}
+
+table {
+  border-collapse: collapse;
+  width: 100%;
+  margin: 1em 0;
+}
+
+th,
+td {
+  border: 1px solid #ddd;
+  padding: 8px;
+  text-align: left;
+}
+
+th {
+  background-color: #f2f2f2;
+  font-weight: bold;
+}
+
+#toc {
+  background-color: #f8f9fa;
+  padding: 1em;
+  border-radius: 5px;
+  margin-bottom: 2em;
+}
+
+#toc h2 {
+  border-bottom: none;
+  margin-top: 0;
+}
+
+#toc ol {
+  padding-left: 1em;
+}
+
+#toc li {
+  margin-bottom: 0.3em;
+}
+
+#toc a {
+  color: #2c3e50;
+  font-weight: 500;
+}

package/src/utils/templates/scorm/adlcp_rootv1p2.xsd

@@ -0,0 +1,110 @@
+<?xml version="1.0"?>
+<!-- filename=adlcp_rootv1p2.xsd -->
+<!-- Conforms to w3c http://www.w3.org/TR/xmlschema-1/ 2000-10-24-->
+
+<xsd:schema xmlns="http://www.adlnet.org/xsd/adlcp_rootv1p2"
+            targetNamespace="http://www.adlnet.org/xsd/adlcp_rootv1p2"
+            xmlns:xml="http://www.w3.org/XML/1998/namespace"
+            xmlns:imscp="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            elementFormDefault="unqualified"
+            version="ADL Version 1.2">
+
+        <xsd:import namespace="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+         schemaLocation="imscp_rootv1p1p2.xsd"/>
+
+        <xsd:element name="location" type="locationType"/>
+        <xsd:element name="prerequisites" type="prerequisitesType"/>
+        <xsd:element name="maxtimeallowed" type="maxtimeallowedType"/>
+        <xsd:element name="timelimitaction" type="timelimitactionType"/>
+        <xsd:element name="datafromlms" type="datafromlmsType"/>
+        <xsd:element name="masteryscore" type="masteryscoreType"/>
+
+
+        <xsd:element name="schema" type="newSchemaType"/>
+        <xsd:simpleType name="newSchemaType">
+                <xsd:restriction base="imscp:schemaType">
+                        <xsd:enumeration value="ADL SCORM"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:element name="schemaversion" type="newSchemaversionType"/>
+        <xsd:simpleType name="newSchemaversionType">
+                <xsd:restriction base="imscp:schemaversionType">
+                        <xsd:enumeration value="1.2"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+
+        <xsd:attribute name="scormtype">
+            <xsd:simpleType>
+                <xsd:restriction base="xsd:string">
+                   <xsd:enumeration value="asset"/>
+                   <xsd:enumeration value="sco"/>
+                </xsd:restriction>
+            </xsd:simpleType>
+        </xsd:attribute>
+
+        <xsd:simpleType name="locationType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="2000"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+
+        <xsd:complexType name="prerequisitesType">
+           <xsd:simpleContent>
+              <xsd:extension base="prerequisiteStringType">
+                  <xsd:attributeGroup ref="attr.prerequisitetype"/>
+              </xsd:extension>
+           </xsd:simpleContent>
+        </xsd:complexType>
+
+        <xsd:attributeGroup name="attr.prerequisitetype">
+                <xsd:attribute name="type" use="required">
+                        <xsd:simpleType>
+                                <xsd:restriction base="xsd:string">
+                                   <xsd:enumeration value="aicc_script"/>
+                                </xsd:restriction>
+                        </xsd:simpleType>
+                </xsd:attribute>
+        </xsd:attributeGroup>
+
+        <xsd:simpleType name="maxtimeallowedType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="13"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="timelimitactionType">
+                <xsd:restriction base="stringType">
+                        <xsd:enumeration value="exit,no message"/>
+                        <xsd:enumeration value="exit,message"/>
+                        <xsd:enumeration value="continue,no message"/>
+                        <xsd:enumeration value="continue,message"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="datafromlmsType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="255"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="masteryscoreType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="200"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="stringType">
+                <xsd:restriction base="xsd:string"/>
+        </xsd:simpleType>
+        
+        <xsd:simpleType name="prerequisiteStringType">
+                <xsd:restriction base="xsd:string">
+                   <xsd:maxLength value="200"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+</xsd:schema>

package/src/utils/templates/scorm/config/api.js

@@ -0,0 +1,175 @@
+var findAPITries = 0;
+
+function findAPI(win) {
+  while (win.API == null && win.parent != null && win.parent != win) {
+    findAPITries++;
+
+    if (findAPITries > 7) {
+      alert("Error finding API -- too deeply nested.");
+      return null;
+    }
+
+    win = win.parent;
+  }
+  return win.API;
+}
+
+function getAPI() {
+  var theAPI = findAPI(window);
+
+  if (
+    theAPI == null &&
+    window.opener != null &&
+    typeof window.opener != "undefined"
+  ) {
+    theAPI = findAPI(window.opener);
+  }
+  if (theAPI == null) {
+    alert("Unable to find an API adapter");
+  }
+  return theAPI;
+}
+
+var SCORM_TRUE = "true";
+var SCORM_FALSE = "false";
+var SCORM_NO_ERROR = "0";
+
+var finishCalled = false;
+
+var initialized = false;
+
+var API = null;
+
+function ScormProcessInitialize() {
+  var result;
+
+  API = getAPI();
+
+  if (API == null) {
+    alert(
+      "ERROR - Could not establish a connection with the LMS.\n\nYour results may not be recorded."
+    );
+    return;
+  }
+
+  result = API.LMSInitialize("");
+
+  if (result == SCORM_FALSE) {
+    var errorNumber = API.LMSGetLastError();
+    var errorString = API.LMSGetErrorString(errorNumber);
+    var diagnostic = API.LMSGetDiagnostic(errorNumber);
+
+    var errorDescription =
+      "Number: " +
+      errorNumber +
+      "\nDescription: " +
+      errorString +
+      "\nDiagnostic: " +
+      diagnostic;
+
+    alert(
+      "Error - Could not initialize communication with the LMS.\n\nYour results may not be recorded.\n\n" +
+        errorDescription
+    );
+    return;
+  }
+
+  initialized = true;
+}
+
+function ScormProcessFinish() {
+  var result;
+
+  if (initialized == false || finishCalled == true) {
+    return;
+  }
+
+  result = API.LMSFinish("");
+
+  finishCalled = true;
+
+  if (result == SCORM_FALSE) {
+    var errorNumber = API.LMSGetLastError();
+    var errorString = API.LMSGetErrorString(errorNumber);
+    var diagnostic = API.LMSGetDiagnostic(errorNumber);
+
+    var errorDescription =
+      "Number: " +
+      errorNumber +
+      "\nDescription: " +
+      errorString +
+      "\nDiagnostic: " +
+      diagnostic;
+
+    alert(
+      "Error - Could not terminate communication with the LMS.\n\nYour results may not be recorded.\n\n" +
+        errorDescription
+    );
+    return;
+  }
+}
+
+function ScormProcessGetValue(element) {
+  var result;
+
+  if (initialized == false || finishCalled == true) {
+    return;
+  }
+
+  result = API.LMSGetValue(element);
+
+  if (result == "") {
+    var errorNumber = API.LMSGetLastError();
+
+    if (errorNumber != SCORM_NO_ERROR) {
+      var errorString = API.LMSGetErrorString(errorNumber);
+      var diagnostic = API.LMSGetDiagnostic(errorNumber);
+
+      var errorDescription =
+        "Number: " +
+        errorNumber +
+        "\nDescription: " +
+        errorString +
+        "\nDiagnostic: " +
+        diagnostic;
+
+      alert(
+        "Error - Could not retrieve a value from the LMS.\n\n" +
+          errorDescription
+      );
+      return "";
+    }
+  }
+
+  return result;
+}
+
+function ScormProcessSetValue(element, value) {
+  var result;
+
+  if (initialized == false || finishCalled == true) {
+    return;
+  }
+
+  result = API.LMSSetValue(element, value);
+
+  if (result == SCORM_FALSE) {
+    var errorNumber = API.LMSGetLastError();
+    var errorString = API.LMSGetErrorString(errorNumber);
+    var diagnostic = API.LMSGetDiagnostic(errorNumber);
+
+    var errorDescription =
+      "Number: " +
+      errorNumber +
+      "\nDescription: " +
+      errorString +
+      "\nDiagnostic: " +
+      diagnostic;
+
+    alert(
+      "Error - Could not store a value in the LMS.\n\nYour results may not be recorded.\n\n" +
+        errorDescription
+    );
+    return;
+  }
+}