@learnpack/learnpack 5.0.276 → 5.0.277

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,17 @@
+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 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;
+  }
+}

package/src/utils/templates/scorm/config/index.html

@@ -0,0 +1,210 @@
+<!DOCTYPE html
+    PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+<head>
+    <meta charset="UTF-8">
+    <title>{{title}}</title>
+    <script src="api.js" type="text/javascript"></script>
+    <script type="text/javascript">
+
+
+        var currentPage = null;
+        var startTimeStamp = null;
+        var processedUnload = false;
+        var reachedEnd = false;
+        var language = 'es';
+
+        function doStart() {
+            startTimeStamp = new Date();
+
+            ScormProcessInitialize();
+
+            var completionStatus = ScormProcessGetValue('cmi.core.lesson_status');
+            if (completionStatus == 'not attempted') {
+                ScormProcessSetValue('cmi.core.lesson_status', 'incomplete');
+            }
+
+            var bookmark = ScormProcessGetValue('cmi.core.lesson_location');
+
+            if (bookmark == '') {
+                currentPage = 0;
+            } else {
+                if (
+                    confirm(
+                        'Would you like to resume from where you previously left off?'
+                    )
+                ) {
+                    currentPage = parseInt(bookmark, 10);
+                } else {
+                    currentPage = 0;
+                }
+            }
+
+            goToPage();
+        }
+
+        function goToPage() {
+            ScormProcessSetValue('cmi.core.lesson_location', currentPage);
+        }
+
+        function doUnload(pressedExit) {
+            if (processedUnload == true) {
+                return;
+            }
+
+            processedUnload = true;
+
+            var endTimeStamp = new Date();
+            var totalMilliseconds =
+                endTimeStamp.getTime() - startTimeStamp.getTime();
+            var scormTime = ConvertMilliSecondsToSCORMTime(
+                totalMilliseconds,
+                false
+            );
+
+            ScormProcessSetValue('cmi.core.session_time', scormTime);
+
+            if (pressedExit == false && reachedEnd == false) {
+                ScormProcessSetValue('cmi.core.exit', 'suspend');
+            }
+
+            ScormProcessFinish();
+        }
+
+        function doPrevious() {
+            if (currentPage > 0) {
+                currentPage--;
+            }
+            goToPage();
+        }
+
+        function doNext() {
+            if (currentPage < pageArray.length - 1) {
+                currentPage++;
+            }
+            goToPage();
+        }
+
+        function doExit() {
+            if (
+                reachedEnd == false &&
+                confirm('Would you like to save your progress to resume later?')
+            ) {
+                ScormProcessSetValue('cmi.core.exit', 'suspend');
+            } else {
+                ScormProcessSetValue('cmi.core.exit', '');
+            }
+
+            doUnload(true);
+        }
+
+        function ConvertMilliSecondsToSCORMTime(
+            intTotalMilliseconds,
+            blnIncludeFraction
+        ) {
+            var intHours;
+            var intintMinutes;
+            var intSeconds;
+            var intMilliseconds;
+            var intHundredths;
+            var strCMITimeSpan;
+
+            if (blnIncludeFraction == null || blnIncludeFraction == undefined) {
+                blnIncludeFraction = true;
+            }
+
+            intMilliseconds = intTotalMilliseconds % 1000;
+
+            intSeconds = ((intTotalMilliseconds - intMilliseconds) / 1000) % 60;
+
+            intMinutes =
+                ((intTotalMilliseconds - intMilliseconds - intSeconds * 1000) /
+                    60000) %
+                60;
+
+            intHours =
+                (intTotalMilliseconds -
+                    intMilliseconds -
+                    intSeconds * 1000 -
+                    intMinutes * 60000) /
+                3600000;
+
+            if (intHours == 10000) {
+                intHours = 9999;
+
+                intMinutes = (intTotalMilliseconds - intHours * 3600000) / 60000;
+                if (intMinutes == 100) {
+                    intMinutes = 99;
+                }
+                intMinutes = Math.floor(intMinutes);
+
+                intSeconds =
+                    (intTotalMilliseconds - intHours * 3600000 - intMinutes * 60000) /
+                    1000;
+                if (intSeconds == 100) {
+                    intSeconds = 99;
+                }
+                intSeconds = Math.floor(intSeconds);
+
+                intMilliseconds =
+                    intTotalMilliseconds -
+                    intHours * 3600000 -
+                    intMinutes * 60000 -
+                    intSeconds * 1000;
+            }
+
+            intHundredths = Math.floor(intMilliseconds / 10);
+
+            strCMITimeSpan =
+                ZeroPad(intHours, 4) +
+                ':' +
+                ZeroPad(intMinutes, 2) +
+                ':' +
+                ZeroPad(intSeconds, 2);
+
+            if (blnIncludeFraction) {
+                strCMITimeSpan += '.' + intHundredths;
+            }
+
+            if (intHours > 9999) {
+                strCMITimeSpan = '9999:99:99';
+
+                if (blnIncludeFraction) {
+                    strCMITimeSpan += '.99';
+                }
+            }
+
+            return strCMITimeSpan;
+        }
+
+        function ZeroPad(intNum, intNumDigits) {
+            var strTemp;
+            var intLen;
+            var i;
+
+            strTemp = new String(intNum);
+            intLen = strTemp.length;
+
+            if (intLen > intNumDigits) {
+                strTemp = strTemp.substr(0, intNumDigits);
+            } else {
+                for (i = intLen; i < intNumDigits; i++) {
+                    strTemp = '0' + strTemp;
+                }
+            }
+            return strTemp;
+        }
+
+
+    </script>
+    <link rel="stylesheet" href="app.css">
+</head>
+
+<body onload="doStart();" onbeforeunload="doUnload(false);" onunload="doUnload();">
+    <div id="root"></div>
+</body>
+
+<script type="module" src="app.js"></script>
+
+</html>

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

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><!-- filename=ims_xml.xsd --><xsd:schema xmlns="http://www.w3.org/XML/1998/namespace"             targetNamespace="http://www.w3.org/XML/1998/namespace"             xmlns:xsd="http://www.w3.org/2001/XMLSchema"             elementFormDefault="qualified">	<!-- 2001-02-22 edited by Thomas Wason IMS Global Learning Consortium, Inc. -->	<xsd:annotation>		<xsd:documentation>In namespace-aware XML processors, the &quot;xml&quot; prefix is bound to the namespace name http://www.w3.org/XML/1998/namespace.</xsd:documentation>		<xsd:documentation>Do not reference this file in XML instances</xsd:documentation>                <xsd:documentation>Schawn Thropp: Changed the uriReference type to string type</xsd:documentation>	</xsd:annotation>	<xsd:attribute name="lang" type="xsd:language">		<xsd:annotation>			<xsd:documentation>Refers to universal  XML 1.0 lang attribute</xsd:documentation>		</xsd:annotation>	</xsd:attribute>	<xsd:attribute name="base" type="xsd:string">		<xsd:annotation>			<xsd:documentation>Refers to XML Base: http://www.w3.org/TR/xmlbase</xsd:documentation>		</xsd:annotation>	</xsd:attribute>	<xsd:attribute name="link" type="xsd:string"/></xsd:schema>