@epic-web/workshop-utils 6.84.1 → 6.84.3

package/dist/epic-api.server.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { getExercises, getWorkshopFinished, getWorkshopInstructions } from "./apps.server.js";
 import { type Timings } from "./timing.server.js";
 declare const EpicVideoMetadataSchema: z.ZodObject<{
     playbackId: z.ZodString;
@@ -81,29 +82,60 @@ export declare function getProgress({ timings, request, }?: {
     epicLessonUrl: string;
     epicLessonSlug: string;
     epicCompletedAt: string | null;
-} & ({
+} & (LocalProgressForEpicLesson | {
+    type: "unknown";
+}))[]>;
+export type LocalProgressForEpicLesson = {
+    type: 'workshop-instructions';
+} | {
+    type: 'workshop-finished';
+} | {
+    type: 'instructions';
+    exerciseNumber: number;
+} | {
+    type: 'finished';
+    exerciseNumber: number;
+} | {
+    type: 'step';
+    exerciseNumber: number;
+    stepNumber: number;
+    stepType: 'problem' | 'solution';
+};
+export declare function resolveLocalProgressForEpicLesson(epicLessonSlug: string, { workshopInstructions, workshopFinished, exercises, }: {
+    workshopInstructions: Awaited<ReturnType<typeof getWorkshopInstructions>>;
+    workshopFinished: Awaited<ReturnType<typeof getWorkshopFinished>>;
+    exercises: Awaited<ReturnType<typeof getExercises>>;
+}): {
     readonly type: "workshop-instructions";
     readonly exerciseNumber?: undefined;
     readonly stepNumber?: undefined;
+    readonly stepType?: undefined;
 } | {
     readonly type: "workshop-finished";
     readonly exerciseNumber?: undefined;
     readonly stepNumber?: undefined;
+    readonly stepType?: undefined;
 } | {
     readonly type: "instructions";
     readonly exerciseNumber: number;
     readonly stepNumber?: undefined;
+    readonly stepType?: undefined;
 } | {
     readonly type: "finished";
     readonly exerciseNumber: number;
     readonly stepNumber?: undefined;
+    readonly stepType?: undefined;
 } | {
     readonly type: "step";
     readonly exerciseNumber: number;
     readonly stepNumber: number;
+    readonly stepType: "problem";
 } | {
-    type: "unknown";
-} | undefined))[]>;
+    readonly type: "step";
+    readonly exerciseNumber: number;
+    readonly stepNumber: number;
+    readonly stepType: "solution";
+} | undefined;
 export declare function updateProgress({ lessonSlug, complete }: {
     lessonSlug: string;
     complete?: boolean;

package/dist/epic-api.server.js

@@ -216,6 +216,11 @@ async function getEpicVideoInfo({ epicVideoEmbed, accessToken, request, timings,
             if (epicUrl.pathname.startsWith('/tutorials/')) {
                 epicUrl.pathname = epicUrl.pathname.replace(/^\/tutorials\//, '/workshops/');
             }
+            const epicPathSegments = epicUrl.pathname.split('/').filter(Boolean);
+            if (epicPathSegments.at(-1) === 'embed') {
+                epicPathSegments.pop();
+                epicUrl.pathname = `/${epicPathSegments.join('/')}`;
+            }
             // special case for epicai.pro videos
             const apiUrl = epicUrl.host === 'www.epicai.pro'
                 ? getEpicAIVideoAPIUrl(epicVideoEmbed)
@@ -431,7 +436,7 @@ export async function getProgress({ timings, request, } = {}) {
             const epicLessonSlug = lesson.slug;
             const lessonProgress = epicProgress.find(({ lessonId }) => lessonId === lesson._id);
             const epicCompletedAt = lessonProgress ? lessonProgress.completedAt : null;
-            const progressForLesson = getProgressForLesson(epicLessonSlug, {
+            const progressForLesson = resolveLocalProgressForEpicLesson(epicLessonSlug, {
                 workshopInstructions,
                 workshopFinished,
                 exercises,
@@ -458,8 +463,60 @@ export async function getProgress({ timings, request, } = {}) {
     log(`processed ${progress.length} progress entries for workshop: ${slug}`);
     return progress;
 }
-function getProgressForLesson(epicLessonSlug, { workshopInstructions, workshopFinished, exercises, }) {
-    const hasEmbed = (embed) => embed?.some((e) => e.split('/').at(-1) === epicLessonSlug);
+function stripEpicAiSlugSuffix(value) {
+    // EpicAI embeds sometimes include a `~...` suffix in the slug segment.
+    // Keep the comparison tolerant by stripping it.
+    return value.replace(/~[^ ]*$/, '');
+}
+function isProblemOrSolutionSubpage(value) {
+    return value === 'problem' || value === 'solution';
+}
+function parseEpicLessonSlugFromEmbedUrl(urlString) {
+    const parseSegments = (segments) => {
+        if (segments.length === 0)
+            return { lessonSlug: null, subpage: null };
+        const last = segments.at(-1) ?? null;
+        if (!last)
+            return { lessonSlug: null, subpage: null };
+        // `/embed` can be appended to either the lesson page itself or a
+        // `/problem`/`/solution` subpage (e.g. `/lesson/solution/embed`). Strip it
+        // first so we can apply the subpage logic consistently.
+        if (last === 'embed')
+            return parseSegments(segments.slice(0, -1));
+        if (isProblemOrSolutionSubpage(last)) {
+            const slug = segments.at(-2) ?? null;
+            return {
+                lessonSlug: slug ? stripEpicAiSlugSuffix(slug) : null,
+                subpage: last,
+            };
+        }
+        return { lessonSlug: stripEpicAiSlugSuffix(last), subpage: null };
+    };
+    try {
+        const url = new URL(urlString);
+        const segments = url.pathname.split('/').filter(Boolean);
+        return parseSegments(segments);
+    }
+    catch {
+        // Fall back to naive parsing; this is best-effort and only used for
+        // mapping Epic lesson slugs -> local pages in admin UI/progress.
+        const withoutHash = urlString.split('#')[0] ?? urlString;
+        const withoutQuery = withoutHash.split('?')[0] ?? withoutHash;
+        const segments = withoutQuery.split('/').filter(Boolean);
+        return parseSegments(segments);
+    }
+}
+function embedMatchesLessonSlug(embedUrl, epicLessonSlug) {
+    const parsed = parseEpicLessonSlugFromEmbedUrl(embedUrl);
+    if (!parsed.lessonSlug)
+        return false;
+    if (parsed.lessonSlug === epicLessonSlug)
+        return true;
+    const normalizedLessonSlug = stripEpicAiSlugSuffix(epicLessonSlug);
+    return parsed.lessonSlug === normalizedLessonSlug;
+}
+export function resolveLocalProgressForEpicLesson(epicLessonSlug, { workshopInstructions, workshopFinished, exercises, }) {
+    const hasEmbed = (embeds) => embeds?.some((embedUrl) => embedMatchesLessonSlug(embedUrl, epicLessonSlug));
     if (workshopInstructions.compiled.status === 'success' &&
         hasEmbed(workshopInstructions.compiled.epicVideoEmbeds)) {
         return { type: 'workshop-instructions' };
@@ -487,6 +544,15 @@ function getProgressForLesson(epicLessonSlug, { workshopInstructions, workshopFi
                     type: 'step',
                     exerciseNumber: exercise.exerciseNumber,
                     stepNumber: step.stepNumber,
+                    stepType: 'problem',
+                };
+            }
+            if (hasEmbed(step.solution?.epicVideoEmbeds)) {
+                return {
+                    type: 'step',
+                    exerciseNumber: exercise.exerciseNumber,
+                    stepNumber: step.stepNumber,
+                    stepType: 'solution',
                 };
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-web/workshop-utils",
-  "version": "6.84.1",
+  "version": "6.84.3",
   "publishConfig": {
     "access": "public"
   },