@learnpack/learnpack 5.0.308 → 5.0.309

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@learnpack/learnpack",
   "description": "Seamlessly build, sell and/or take interactive & auto-graded tutorials, start learning now or build a new tutorial to your audience.",
-  "version": "5.0.308",
+  "version": "5.0.309",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {

package/src/creator/src/utils/lib.ts

@@ -1,21 +1,21 @@
-import axios from "axios"
-import { franc } from "franc"
-import { BREATHECODE_HOST, DEV_MODE, RIGOBOT_HOST } from "./constants"
-import { Lesson } from "../components/LessonItem"
-import { randomUUID } from "./creatorUtils"
-import { Syllabus } from "./store"
+import axios from "axios";
+import { franc } from "franc";
+import { BREATHECODE_HOST, DEV_MODE, RIGOBOT_HOST } from "./constants";
+import { Lesson } from "../components/LessonItem";
+import { randomUUID } from "./creatorUtils";
+import { Syllabus } from "./store";
 
 export function parseLesson(input: string, previous: Lesson[]): Lesson | null {
-  const pattern = /^([\d.]+)\s*-\s*(.*?)\s*\[(\w+):\s*(.+)\]$/
-  const match = input.match(pattern)
+  const pattern = /^([\d.]+)\s*-\s*(.*?)\s*\[(\w+):\s*(.+)\]$/;
+  const match = input.match(pattern);
 
-  if (!match) return null
+  if (!match) return null;
 
-  const [, index, title, type, description] = match
+  const [, index, title, type, description] = match;
 
   const alreadyExistsIndex = previous.findIndex(
     (lesson) => lesson.id === index && lesson.title === title
-  )
+  );
 
   if (alreadyExistsIndex !== -1) {
     return {
@@ -26,7 +26,7 @@ export function parseLesson(input: string, previous: Lesson[]): Lesson | null {
       description: description.trim(),
       duration: previous[alreadyExistsIndex].duration,
       locked: previous[alreadyExistsIndex].locked || false,
-    }
+    };
   }
 
   return {
@@ -37,51 +37,51 @@ export function parseLesson(input: string, previous: Lesson[]): Lesson | null {
     duration: 2,
     uid: randomUUID(),
     locked: false,
-  }
+  };
 }
 
 export const uploadFileToBucket = async (content: string, path: string) => {
   const response = await axios.post(`/upload`, {
     content,
     destination: path,
-  })
-  return response.data
-}
+  });
+  return response.data;
+};
 export const uploadImageToBucket = async (imageUrl: string, path: string) => {
   const response = await axios.post(`/upload-image`, {
     image_url: imageUrl,
     destination: path,
-  })
-  return response.data
-}
+  });
+  return response.data;
+};
 
 export const checkParams = (paramsToCheck: string[]) => {
-  const urlParams = new URLSearchParams(window.location.search)
-  const result: Record<string, string> = {}
+  const urlParams = new URLSearchParams(window.location.search);
+  const result: Record<string, string> = {};
 
   paramsToCheck.forEach((param) => {
-    const value = urlParams.get(param)
+    const value = urlParams.get(param);
     if (value !== null) {
-      result[param] = value
+      result[param] = value;
     }
-  })
+  });
 
-  return result
-}
+  return result;
+};
 
 export async function getConsumables(token: string): Promise<any> {
-  const url = `${BREATHECODE_HOST}/v1/payments/me/service/consumable?virtual=true`
+  const url = `${BREATHECODE_HOST}/v1/payments/me/service/consumable?virtual=true`;
 
   const headers = {
     Authorization: `Token ${token}`,
-  }
+  };
 
   try {
-    const response = await axios.get(url, { headers })
-    return response.data
+    const response = await axios.get(url, { headers });
+    return response.data;
   } catch (error) {
-    console.error("Error fetching consumables:", error)
-    throw error
+    console.error("Error fetching consumables:", error);
+    throw error;
   }
 }
 
@@ -89,78 +89,78 @@ type ConsumableSlug =
   | "ai-conversation-message"
   | "ai-compilation"
   | "ai-generation"
-  | "ai-course-generation"
+  | "ai-course-generation";
 
 export async function useConsumableCall(
   breathecodeToken: string,
   consumableSlug: ConsumableSlug = "ai-conversation-message"
 ): Promise<boolean> {
-  const url = `${BREATHECODE_HOST}/v1/payments/me/service/${consumableSlug}/consumptionsession`
+  const url = `${BREATHECODE_HOST}/v1/payments/me/service/${consumableSlug}/consumptionsession`;
 
   const headers = {
     Authorization: `Token ${breathecodeToken}`,
-  }
+  };
 
   try {
-    const response = await axios.put(url, {}, { headers })
+    const response = await axios.put(url, {}, { headers });
 
     if (response.status >= 200 && response.status < 300) {
-      console.log(`Successfully consumed ${consumableSlug}`)
-      return true
+      console.log(`Successfully consumed ${consumableSlug}`);
+      return true;
     } else {
-      console.error(`Request failed with status code: ${response.status}`)
-      console.error(`Response: ${response.data}`)
-      return false
+      console.error(`Request failed with status code: ${response.status}`);
+      console.error(`Response: ${response.data}`);
+      return false;
     }
   } catch (error) {
-    console.error(`Error consuming ${consumableSlug}:`, error)
-    return false
+    console.error(`Error consuming ${consumableSlug}:`, error);
+    return false;
   }
 }
 
 type ConsumableItem = {
-  id: number
-  how_many: number
-  unit_type: string
-  valid_until: string | null
-}
+  id: number;
+  how_many: number;
+  unit_type: string;
+  valid_until: string | null;
+};
 
 type VoidEntry = {
-  id: number
-  slug: string
-  balance: { unit: number }
-  items: ConsumableItem[]
-}
+  id: number;
+  slug: string;
+  balance: { unit: number };
+  items: ConsumableItem[];
+};
 
 export const parseConsumables = (
   voids: VoidEntry[]
 ): Record<string, number> => {
-  const result: Record<string, number> = {}
+  const result: Record<string, number> = {};
 
   voids.forEach((entry) => {
     const maxHowMany = entry.items.length
       ? Math.max(...entry.items.map((item) => item.how_many))
-      : 0
-    result[entry.slug] = maxHowMany
-  })
+      : 0;
+    result[entry.slug] = maxHowMany;
+  });
 
-  return result
-}
+  return result;
+};
 
 type LoginInfo = {
-  email: string
-  password: string
-}
+  email: string;
+  password: string;
+};
 
 export const getRigobotJSON = async (breathecodeToken: string) => {
-  const rigoUrl = `${RIGOBOT_HOST}/v1/auth/me/token?breathecode_token=${breathecodeToken}`
-  const rigoResp = await fetch(rigoUrl)
+  const rigoUrl = `${RIGOBOT_HOST}/v1/auth/me/token?breathecode_token=${breathecodeToken}`;
+  const rigoResp = await fetch(rigoUrl);
   if (!rigoResp.ok) {
-    throw new Error("Unable to obtain Rigobot token")
+    throw new Error("Unable to obtain Rigobot token");
   }
-  const rigobotJson = await rigoResp.json()
-  return rigobotJson
-}
+  const rigobotJson = await rigoResp.json();
+  return rigobotJson;
+};
 export const validateUser = async (breathecodeToken: string) => {
   const config = {
     method: "GET",
@@ -168,30 +168,30 @@ export const validateUser = async (breathecodeToken: string) => {
       "Content-Type": "application/json",
       Authorization: `Token ${breathecodeToken}`,
     },
-  }
+  };
 
-  const res = await fetch(`${BREATHECODE_HOST}/v1/auth/user/me`, config)
+  const res = await fetch(`${BREATHECODE_HOST}/v1/auth/user/me`, config);
   if (!res.ok) {
-    console.log("ERROR", res)
-    return null
+    console.log("ERROR", res);
+    return null;
   }
-  const json = await res.json()
+  const json = await res.json();
 
   if ("roles" in json) {
-    delete json.roles
+    delete json.roles;
   }
   if ("permissions" in json) {
-    delete json.permissions
+    delete json.permissions;
   }
   if ("settings" in json) {
-    delete json.settings
+    delete json.settings;
   }
 
-  return json
-}
+  return json;
+};
 
 export const login4Geeks = async (loginInfo: LoginInfo) => {
-  const url = `${BREATHECODE_HOST}/v1/auth/login/`
+  const url = `${BREATHECODE_HOST}/v1/auth/login/`;
 
   const res = await fetch(url, {
     body: JSON.stringify(loginInfo),
@@ -199,87 +199,87 @@ export const login4Geeks = async (loginInfo: LoginInfo) => {
     headers: {
       "Content-Type": "application/json",
     },
-  })
+  });
 
   if (!res.ok) {
-    throw Error("Unable to login with provided credentials")
+    throw Error("Unable to login with provided credentials");
   }
 
-  const json = await res.json()
+  const json = await res.json();
 
-  const rigoJson = await getRigobotJSON(json.token)
+  const rigoJson = await getRigobotJSON(json.token);
 
-  const user = await validateUser(json.token)
-  const returns = { ...json, rigobot: { ...rigoJson }, user }
+  const user = await validateUser(json.token);
+  const returns = { ...json, rigobot: { ...rigoJson }, user };
 
-  return returns
-}
+  return returns;
+};
 
 export const loginWithToken = async (token: string) => {
-  const rigoJson = await getRigobotJSON(token)
+  const rigoJson = await getRigobotJSON(token);
 
-  const user = await validateUser(token)
+  const user = await validateUser(token);
 
-  const returns = { rigobot: { ...rigoJson }, ...user }
+  const returns = { rigobot: { ...rigoJson }, ...user };
 
-  return returns
-}
+  return returns;
+};
 
 export const validateTokens = async (
   breathecodeToken: string,
   onValidRigoToken: (token: string) => void
 ) => {
-  const user = await validateUser(breathecodeToken)
-  console.log("USER", user)
+  const user = await validateUser(breathecodeToken);
+  console.log("USER", user);
   if (!user) {
-    return false
+    return false;
   }
 
-  const rigobotJson = await getRigobotJSON(breathecodeToken)
+  const rigobotJson = await getRigobotJSON(breathecodeToken);
   if (!rigobotJson) {
-    return false
+    return false;
   }
-  onValidRigoToken(rigobotJson.key)
-  return true
-}
+  onValidRigoToken(rigobotJson.key);
+  return true;
+};
 
 export function extractImagesFromMarkdown(markdown: string) {
-  const imageRegex = /!\[([^\]]*)]\(([^)]+)\)/g
-  const images = []
-  let match
+  const imageRegex = /!\[([^\]]*)]\(([^)]+)\)/g;
+  const images = [];
+  let match;
 
   while ((match = imageRegex.exec(markdown)) !== null) {
-    const altText = match[1]
-    const url = match[2]
-    images.push({ alt: altText, url: url })
+    const altText = match[1];
+    const url = match[2];
+    images.push({ alt: altText, url: url });
   }
 
-  return images
+  return images;
 }
 
 export function getFilenameFromUrl(url: string): string {
   try {
     // 1) Use the URL constructor to strip off protocol/host/search/hash
-    const pathname = new URL(url, location.href).pathname
+    const pathname = new URL(url, location.href).pathname;
     // 2) Grab everything after the last “/”
-    return pathname.substring(pathname.lastIndexOf("/") + 1)
+    return pathname.substring(pathname.lastIndexOf("/") + 1);
   } catch {
     // Fallback for non-absolute URLs or invalid inputs
-    const clean = url.split("?")[0].split("#")[0]
-    return clean.substring(clean.lastIndexOf("/") + 1)
+    const clean = url.split("?")[0].split("#")[0];
+    return clean.substring(clean.lastIndexOf("/") + 1);
   }
 }
 
 export const makeCallbackUrl = (slug: string) => {
   if (DEV_MODE) {
-    return `https://8000-charlytoc-rigobot-bmwdeam7cev.ws-us120.gitpod.io/v1/learnpack/tools/images/callback?slug=${slug}`
+    return `https://8000-charlytoc-rigobot-bmwdeam7cev.ws-us120.gitpod.io/v1/learnpack/tools/images/callback?slug=${slug}`;
   }
-  return `${window.location.origin}/api/v1/webhooks/images`
-}
+  return `${window.location.origin}/api/v1/webhooks/images`;
+};
 
 type TGenerateImageParams = {
-  prompt: string
-}
+  prompt: string;
+};
 
 export const generateImage = async (
   token: string,
@@ -298,14 +298,14 @@ export const generateImage = async (
           Authorization: "Token " + token,
         },
       }
-    )
+    );
 
-    return response.data
+    return response.data;
   } catch (error) {
-    console.error("Error generating image:", error)
-    return null
+    console.error("Error generating image:", error);
+    return null;
   }
-}
+};
 
 export const createCourse = async (
   syllabus: Syllabus,
@@ -323,27 +323,27 @@ export const createCourse = async (
         "x-rigo-token": token,
       },
     }
-  )
-  return response.data
-}
+  );
+  return response.data;
+};
 
 interface SlugAvailabilityResponse {
-  slug: string
-  available: boolean
+  slug: string;
+  available: boolean;
 }
 
 export const isSlugAvailable = async (slug: string): Promise<boolean> => {
   try {
     const url = `${RIGOBOT_HOST}/v1/learnpack/check-slug-availability?slug=${encodeURIComponent(
       slug
-    )}`
-    const response = await axios.get<SlugAvailabilityResponse>(url)
-    return response.data.available
+    )}`;
+    const response = await axios.get<SlugAvailabilityResponse>(url);
+    return response.data.available;
   } catch (error) {
-    console.error("Error checking slug availability:", error)
-    throw error
+    console.error("Error checking slug availability:", error);
+    throw error;
   }
-}
+};
 
 export const reWriteTitle = async (title: string, token: string) => {
   // We hav in the parsed the newTitle
@@ -363,25 +363,25 @@ export const reWriteTitle = async (title: string, token: string) => {
           Authorization: "Token " + token,
         },
       }
-    )
-    console.log("RESPONSE", response.data)
-    return response.data.parsed.newTitle
+    );
+    console.log("RESPONSE", response.data);
+    return response.data.parsed.newTitle;
   } catch (error) {
-    console.error("Error rewriting title:", error)
+    console.error("Error rewriting title:", error);
     // Return the title as it is with a random number of 4 characters
-    return `${title} ${Math.random().toString(36).substring(2, 6)}`
+    return `${title} ${Math.random().toString(36).substring(2, 6)}`;
   }
-}
+};
 
 export async function registerUserWithFormData(
   firstName: string,
   lastName: string,
   email: string
 ): Promise<any> {
-  const formData = new FormData()
-  formData.append("1_first_name", firstName)
-  formData.append("1_last_name", lastName)
-  formData.append("1_email", email)
+  const formData = new FormData();
+  formData.append("1_first_name", firstName);
+  formData.append("1_last_name", lastName);
+  formData.append("1_email", email);
 
   // Puedes modificar este objeto para agregar info real de tracking si la tienes.
   const conversionArray = [
@@ -402,9 +402,9 @@ export async function registerUserWithFormData(
       internal_cta_content: "$undefined",
       internal_cta_campaign: "$undefined",
     },
-  ]
+  ];
 
-  formData.append("0", JSON.stringify(conversionArray))
+  formData.append("0", JSON.stringify(conversionArray));
 
   try {
     const response = await axios.post(
@@ -415,57 +415,57 @@ export async function registerUserWithFormData(
           "Content-Type": "multipart/form-data",
         },
       }
-    )
-    return response.data
+    );
+    return response.data;
   } catch (error: any) {
     // Manejo de errores básico
-    console.error(error, "ERROR REGISTERING IN LEARNPACK")
+    console.error(error, "ERROR REGISTERING IN LEARNPACK");
     return {
       success: false,
       message: error?.response?.data?.detail || "Registration error",
       data: error?.response?.data || null,
-    }
+    };
   }
 }
 
 export const isValidRigoToken = async (rigobotToken: string) => {
-  const rigoUrl = `${RIGOBOT_HOST}/v1/auth/token/${rigobotToken}`
-  const rigoResp = await fetch(rigoUrl)
+  const rigoUrl = `${RIGOBOT_HOST}/v1/auth/token/${rigobotToken}`;
+  const rigoResp = await fetch(rigoUrl);
   if (!rigoResp.ok) {
-    return false
+    return false;
   }
 
-  return true
-}
+  return true;
+};
 export const isValidPublicToken = async (publicToken: string) => {
   const headers = {
     "Content-Type": "application/json",
     Authorization: "Token " + publicToken,
-  }
-  const rigoUrl = `${RIGOBOT_HOST}/v1/auth/public/token/validate`
-  const rigoResp = await fetch(rigoUrl, { headers })
+  };
+  const rigoUrl = `${RIGOBOT_HOST}/v1/auth/public/token/validate`;
+  const rigoResp = await fetch(rigoUrl, { headers });
   if (!rigoResp.ok) {
-    return false
+    return false;
   }
 
-  return true
-}
+  return true;
+};
 
 export const fixTitleLength = (title: string) => {
-  const MAX_LENGTH = 49
-  let fixed = title.slice(0, MAX_LENGTH)
-  fixed = fixed.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
-  return fixed
-}
+  const MAX_LENGTH = 49;
+  let fixed = title.slice(0, MAX_LENGTH);
+  fixed = fixed.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "");
+  return fixed;
+};
 
 export const getTechnologies = async () => {
-  const response = await axios.get(`/technologies`)
-  return response.data
-}
+  const response = await axios.get(`/technologies`);
+  return response.data;
+};
 
 export const detectLanguage = (text: string) => {
-  const lang = franc(text)
-  if (lang === "spa") return "es"
-  if (lang === "eng") return "en"
-  return "en" // fallback to English
-}
+  const lang = franc(text);
+  if (lang === "spa") return "es";
+  if (lang === "eng") return "en";
+  return "en"; // fallback to English
+};