academe-kit 0.11.4 → 0.11.6

package/dist/index.d.ts

@@ -124,6 +124,8 @@ interface AcademeLoadingColors {
     /** Círculo branco ("face"). */
     white: string;
 }
+/** Tema visual da vinheta. `light` (default) preserva o fundo claro atual; `dark` usa o fundo escuro da marca. */
+type AcademeLoadingTheme = "light" | "dark";
 interface AcademeLoadingProps {
     /** Lado do palco quadrado, em px. Default 320. */
     size?: number;
@@ -140,12 +142,17 @@ interface AcademeLoadingProps {
     pulseWhileLoading?: boolean;
     /** Chamado ao concluir (após a saída, ou após a vinheta completa). */
     onFinish?: () => void;
-    /** Sobrescreve tokens de cor (merge com os defaults medidos do vídeo). */
+    /**
+     * Tema visual base. `light` (default) mantém o fundo claro atual; `dark` aplica
+     * a paleta escura da marca. O `colors` ainda sobrescreve qualquer token por cima.
+     */
+    theme?: AcademeLoadingTheme;
+    /** Sobrescreve tokens de cor (merge com os defaults do tema selecionado). */
     colors?: Partial<AcademeLoadingColors>;
     className?: string;
     style?: React.CSSProperties;
 }
-declare function AcademeLoading({ size, duration, loading, autoPlay, pulseWhileLoading, onFinish, colors, className, style, }: AcademeLoadingProps): react_jsx_runtime.JSX.Element;
+declare function AcademeLoading({ size, duration, loading, autoPlay, pulseWhileLoading, onFinish, theme, colors, className, style, }: AcademeLoadingProps): react_jsx_runtime.JSX.Element;
 
 interface LogoAProps {
     /** Altura do logo em px (no palco corresponde a ~0.46·S). Largura é derivada
@@ -3036,6 +3043,94 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/challenges/{id}/participants": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the students taking part in this challenge
+         * @description Returns the roster of students for the challenge along with each
+         *     student's status, derived from `submissions` (latest attempt) and
+         *     `user_challenge_progress` (whether any step was started).
+         *
+         *     The roster is built from `institution_registration` rows of the given
+         *     institution, filtered by the challenge's serie. `institutionId` and
+         *     `serieId` may be supplied via query to provide the viewing context —
+         *     useful for global template challenges (`institution_id IS NULL`) shown
+         *     via fallback in the pedagogical portal. They default to the
+         *     challenge's own institution/serie when omitted.
+         *
+         *     Status values: `novo` (not started), `andamento` (started a step, no
+         *     submission), `entregue` (submitted | ai_evaluated), `aprovado`
+         *     (approved), `rejeitado` (rejected).
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Viewing institution. Defaults to the challenge's institution. */
+                    institutionId?: string;
+                    /** @description Serie filter. Defaults to the challenge's serie. */
+                    serieId?: string;
+                };
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    id: components["parameters"]["id"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Roster of participants with derived status */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: {
+                                totalStudents?: number;
+                                classrooms?: {
+                                    /** Format: uuid */
+                                    id?: string;
+                                    name?: string;
+                                    count?: number;
+                                }[];
+                                participants?: {
+                                    /** Format: uuid */
+                                    userId?: string;
+                                    name?: string;
+                                    email?: string | null;
+                                    avatarUrl?: string | null;
+                                    /** Format: uuid */
+                                    classroomId?: string | null;
+                                    classroomName?: string | null;
+                                    /** @enum {string} */
+                                    status?: "novo" | "andamento" | "entregue" | "aprovado" | "rejeitado";
+                                    /** Format: uuid */
+                                    submissionId?: string | null;
+                                }[];
+                            };
+                        };
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                404: components["responses"]["NotFound"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/classrooms": {
         parameters: {
             query?: never;
@@ -11983,6 +12078,12 @@ interface paths {
          *     - Cannot create after status=approved
          *     - Cannot exceed challenge.maxSubmissionsAttempts
          *     - attempt_number is computed server-side with a row lock (FOR UPDATE)
+         *
+         *     When `items` is provided, the submission and its files/links are persisted
+         *     in the SAME transaction (atomic) and AI evaluation is dispatched after commit.
+         *     Each item must have exactly ONE of fileId or url, and must match the
+         *     challenge.submissionType (file types require fileId; links require url).
+         *     This is the preferred path for clients (no separate POST /submissions/{id}/files).
          */
         post: {
             parameters: {
@@ -12007,6 +12108,17 @@ interface paths {
                          */
                         groupId?: string;
                         description?: string;
+                        /**
+                         * @description Submission delivery. When present, files/links are stored atomically
+                         *     with the submission and AI evaluation is dispatched after commit.
+                         */
+                        items?: {
+                            /** Format: uuid */
+                            fileId?: string | null;
+                            /** Format: uri */
+                            url?: string | null;
+                            index?: number;
+                        }[];
                     };
                 };
             };
@@ -12021,6 +12133,45 @@ interface paths {
                             /** @example success */
                             status?: string;
                             data?: components["schemas"]["Submission"];
+                            /**
+                             * @description Journey side-effects of the submission. On the FIRST attempt the
+                             *     publication step is completed and the user advances; `advance`
+                             *     carries the resulting tick so the client can animate the journey.
+                             *     `advance` is null on re-submissions (attempt > 1) or if the advance
+                             *     step failed (non-fatal — the submission is still created).
+                             */
+                            meta?: {
+                                advance?: {
+                                    /** @enum {string} */
+                                    action?: "started" | "completed" | "finished";
+                                    /** Format: uuid */
+                                    challengeId?: string;
+                                    currentStep?: {
+                                        /** Format: uuid */
+                                        id?: string;
+                                        index?: number;
+                                        name?: string;
+                                        /** Format: date-time */
+                                        startedAt?: string | null;
+                                        /** Format: date-time */
+                                        completedAt?: string | null;
+                                    } | null;
+                                    nextStep?: {
+                                        /** Format: uuid */
+                                        id?: string;
+                                        index?: number;
+                                        name?: string;
+                                        /** Format: date-time */
+                                        startedAt?: string | null;
+                                    } | null;
+                                    autoCompletedSteps?: {
+                                        /** Format: uuid */
+                                        id?: string;
+                                        index?: number;
+                                        name?: string;
+                                    }[];
+                                } | null;
+                            };
                         };
                     };
                 };
@@ -12084,6 +12235,79 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/submissions/{id}/classroom-rank": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Ordem de entrega do aluno na turma para o desafio desta submissão
+         * @description Retorna a posição do aluno entre os colegas de turma (institution_classroom
+         *     via membership) a entregar o desafio, ordenando pela PRIMEIRA entrega de cada
+         *     aluno (MIN(submitted_at)). Usado pelo app do aluno como incentivo a entregar
+         *     cedo ("Você foi o Nº de X da turma a entregar"). Quando o aluno não tem turma
+         *     na instituição, retorna order=0 e classSize=0 e o cliente esconde o card.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Resource ID */
+                    id: components["parameters"]["id"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Posição na turma */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: {
+                                /**
+                                 * @description Posição do aluno (1-based) entre os que entregaram; 0 quando sem turma
+                                 * @example 3
+                                 */
+                                order?: number;
+                                /**
+                                 * @description Total de alunos da turma (independente de terem entregado)
+                                 * @example 28
+                                 */
+                                classSize?: number;
+                                /**
+                                 * @description Quantos alunos da turma já entregaram o desafio
+                                 * @example 12
+                                 */
+                                submittedCount?: number;
+                                /**
+                                 * @description true quando order está entre 1 e 3
+                                 * @example true
+                                 */
+                                earlyBird?: boolean;
+                            };
+                        };
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+                404: components["responses"]["NotFound"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/submissions/{id}/files": {
         parameters: {
             query?: never;
@@ -12665,6 +12889,12 @@ interface paths {
                      *     Útil para pré-visualização administrativa ou quando o aluno pertence a múltiplas séries.
                      */
                     serieId?: string;
+                    /**
+                     * @description Escola atual (contexto de instituição do app). Opcional — se omitido, usa a 1ª
+                     *     matrícula. A jornada é por escola: filtra os challenges e resolve a turma/série
+                     *     default a partir da membership do usuário NESTA instituição.
+                     */
+                    institutionId?: string;
                     /**
                      * @description [Admin] Quando presente, retorna a jornada do usuário-alvo em vez da do
                      *     autenticado. Usado pelo backoffice para visualizar a jornada de um aluno.
@@ -13562,6 +13792,97 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/users/me/classrooms": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Turmas e séries do usuário autenticado
+         * @description Contexto de matrícula do aluno: TODAS as suas turmas (com série, turno e
+         *     instituição), a escola ATUAL e a lista DEDUPLICADA de séries dessa escola.
+         *
+         *     Fonte única para o app: `classrooms` alimenta a listagem de turmas no
+         *     perfil; `currentInstitutionId` é a escola atual (o app mostra uma escola
+         *     por vez); `series` traz APENAS as séries da escola atual (deduplicada e
+         *     ordenada por nível/valor) — alimenta o seletor da jornada, que também é
+         *     por escola. O botão só aparece com 2+ séries na escola atual.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Turmas + séries acessíveis */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            /** @example success */
+                            status?: string;
+                            data?: {
+                                /**
+                                 * Format: uuid
+                                 * @description Escola atual (a da matrícula). As séries são desta escola.
+                                 */
+                                currentInstitutionId?: string | null;
+                                classrooms?: {
+                                    /** Format: uuid */
+                                    institutionClassroomId?: string;
+                                    /** Format: uuid */
+                                    classroomId?: string;
+                                    /** @example 6º A */
+                                    classroomName?: string;
+                                    /** @example manhã */
+                                    shiftName?: string | null;
+                                    /** Format: uuid */
+                                    institutionId?: string;
+                                    /** @example Escola Modelo */
+                                    institutionName?: string | null;
+                                    serie?: {
+                                        /** Format: uuid */
+                                        serieId?: string;
+                                        /** @example 6 */
+                                        serieValue?: number;
+                                        /** @example 6º ANO */
+                                        serieLabel?: string;
+                                        /** @enum {string} */
+                                        level?: "fundamental" | "medio";
+                                    } | null;
+                                }[];
+                                series?: {
+                                    /** Format: uuid */
+                                    serieId?: string;
+                                    /** @example 6 */
+                                    serieValue?: number;
+                                    /** @example 6º ANO */
+                                    serieLabel?: string;
+                                    /** @enum {string} */
+                                    level?: "fundamental" | "medio";
+                                }[];
+                            };
+                        };
+                    };
+                };
+                401: components["responses"]["Unauthorized"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/users/me/push-tokens": {
         parameters: {
             query?: never;
@@ -15174,6 +15495,8 @@ interface components {
             certificateTemplate?: components["schemas"]["CertificateTemplate"];
             /** @description Course information related to the certificate (extracted from Quiz or CertificateTemplate) */
             course?: components["schemas"]["CourseSimplified"];
+            /** @description Course module information related to the certificate (resolved from the quiz the student took). Null when the certificate came from a template course. */
+            module?: components["schemas"]["ModuleSimplified"];
         };
         /** @description Simplified course information included in certificate responses */
         CourseSimplified: {
@@ -15193,6 +15516,26 @@ interface components {
              */
             description?: string | null;
         };
+        /** @description Simplified course module information included in certificate responses */
+        ModuleSimplified: {
+            /**
+             * Format: uuid
+             * @description Course module ID
+             */
+            id?: string;
+            /**
+             * @description Course module title
+             * @example Variables and Data Types
+             */
+            title?: string;
+            /** @description Course module description */
+            description?: string | null;
+            /**
+             * @description Course module workload in hours
+             * @example 40
+             */
+            duration?: number | null;
+        };
         /** @description Simplified quiz information included in course and module responses */
         QuizSimplified: {
             /**
@@ -26645,6 +26988,11 @@ declare function createSubmissionService(apiClient: AcademeApiClient): {
                     institutionId: string;
                     groupId?: string;
                     description?: string;
+                    items?: {
+                        fileId?: string | null;
+                        url?: string | null;
+                        index?: number;
+                    }[];
                 };
             };
         };
@@ -26657,6 +27005,30 @@ declare function createSubmissionService(apiClient: AcademeApiClient): {
                     "application/json": {
                         status?: string;
                         data?: components["schemas"]["Submission"];
+                        meta?: {
+                            advance?: {
+                                action?: "started" | "completed" | "finished";
+                                challengeId?: string;
+                                currentStep?: {
+                                    id?: string;
+                                    index?: number;
+                                    name?: string;
+                                    startedAt?: string | null;
+                                    completedAt?: string | null;
+                                } | null;
+                                nextStep?: {
+                                    id?: string;
+                                    index?: number;
+                                    name?: string;
+                                    startedAt?: string | null;
+                                } | null;
+                                autoCompletedSteps?: {
+                                    id?: string;
+                                    index?: number;
+                                    name?: string;
+                                }[];
+                            } | null;
+                        };
                     };
                 };
             };
@@ -27300,4 +27672,4 @@ declare enum NINA_ROLES {
 }
 
 export { AcademeAuthProvider, AcademeLoading, BACKOFFICE_ROLES, Button, CosmicDecor, CosmicStarsCanvas, DASHBOARD_ROLES, GLOBAL_ROLES, JourneyCrystalPin, JourneyStep, LogoA, MIKE_ROLES, NINA_ROLES, ProtectedApp, ProtectedComponent, ProtectedRouter, STREAMING_ROLES, Spinner, WIDGET_ROLES, academeApi_d as apiTypes, cn, createAcademeApiClient, index_d as types, useAcademeAuth, useProtectedAppColors };
-export type { AcademeApiClient, AcademeKeycloakContextProps, AcademeLoadingColors, AcademeLoadingProps, AcademeServices, AcademeUser, ButtonProps, ChallengeUserQuizAttempt, ChallengeUserQuizAttemptsResponse, CosmicDecorProps, CosmicDecorVariant, CosmicPlanet, CosmicStarsCanvasProps, FrameKind, JourneyChallengeView, JourneyCrystalPinProps, JourneyStepProps, JourneyStepSize, JourneyStepType, JourneyStepView, JourneyView, KeycloakUser, LogoAProps, RequiredClientRoles, SecurityContextType, SecurityProviderProps };
+export type { AcademeApiClient, AcademeKeycloakContextProps, AcademeLoadingColors, AcademeLoadingProps, AcademeLoadingTheme, AcademeServices, AcademeUser, ButtonProps, ChallengeUserQuizAttempt, ChallengeUserQuizAttemptsResponse, CosmicDecorProps, CosmicDecorVariant, CosmicPlanet, CosmicStarsCanvasProps, FrameKind, JourneyChallengeView, JourneyCrystalPinProps, JourneyStepProps, JourneyStepSize, JourneyStepType, JourneyStepView, JourneyView, KeycloakUser, LogoAProps, RequiredClientRoles, SecurityContextType, SecurityProviderProps };

package/dist/index.esm.js

@@ -6848,6 +6848,9 @@ const LOGO_A_DATA_URI = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlb
 // derivar a largura a partir da altura, preservando a proporção do logo.
 const ASSET_W = 1320;
 const ASSET_H = 1320.42;
+/** Proporção (largura/altura) do asset. O AcademeLoading usa para dimensionar o
+ *  container do logo igual à imagem e mantê-lo centralizado nos círculos. */
+const LOGO_A_ASPECT = ASSET_W / ASSET_H;
 /**
  * Logo "A" da Academe (§8) — renderiza o asset oficial
  * (`src/assets/LOGO A SVG 2.svg`) via data URI. Puramente estático; quem anima é
@@ -6870,10 +6873,24 @@ const TOTAL = 2333;
  */
 const HOLD_T = 0.56;
 const DEFAULT_COLORS = {
-    background: "#F5F5F5",
+    background: "#f1f2f6",
     purple: "#7C28D4",
     white: "#FCFCFC",
 };
+/**
+ * Paleta escura da marca. Só o fundo muda — os círculos roxo/branco continuam os
+ * mesmos (o branco revela o logo e contrasta bem sobre o escuro). O fundo casa com
+ * o tema dark do `ProtectedApp`.
+ */
+const DARK_COLORS = {
+    background: "#111111",
+    purple: "#7C28D4",
+    white: "#FCFCFC",
+};
+const THEME_COLORS = {
+    light: DEFAULT_COLORS,
+    dark: DARK_COLORS,
+};
 // ---- helpers -------------------------------------------------------------
 const clamp01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);
 /** progresso local [0,1] dentro do trecho [a,b] de `t`. */
@@ -6936,9 +6953,9 @@ const E_COLLAPSE = cubicBezier(0.65, 0, 0.35, 1); // colapso (ease-in-out)
 const E_SHRINK = cubicBezier(0.5, 0, 0.9, 0.2); // encolher (ease-in)
 const E_POP = cubicBezier(0.34, 1.2, 0.64, 1); // pop leve do logo (overshoot)
 // ---- component -----------------------------------------------------------
-function AcademeLoading({ size = 320, duration = TOTAL, loading, autoPlay = true, pulseWhileLoading = true, onFinish, colors, className, style, }) {
+function AcademeLoading({ size = 320, duration = TOTAL, loading, autoPlay = true, pulseWhileLoading = true, onFinish, theme = "light", colors, className, style, }) {
     const S = size;
-    const c = { ...DEFAULT_COLORS, ...colors };
+    const c = { ...THEME_COLORS[theme], ...colors };
     const isControlled = loading !== undefined;
     // Os círculos NÃO são recortados por nenhuma "caixa" interna. O palco antigo
     // (size×size com overflow:hidden) cortava os círculos na entrada e no herói.
@@ -7135,7 +7152,7 @@ function AcademeLoading({ size = 320, duration = TOTAL, loading, autoPlay = true
         return 0;
     });
     const LOGO_H = 0.46 * S;
-    const LOGO_W = LOGO_H * (354 / 516);
+    const LOGO_W = LOGO_H * LOGO_A_ASPECT;
     // Centralização determinística: cada camada é absoluta e centralizada por
     // `inset:0 + margin:auto` sobre um width/height fixo — independe do tamanho
     // relativo dos elementos (o grid implícito anterior ancorava a célula no canto,
@@ -7255,7 +7272,7 @@ const ProtectedApp = ({ children, requiredClientRoles, requiredRealmRoles, theme
     // só depois do `onFinish` o app é revelado. Fica montada durante o exit graças
     // ao `!exitDone`.
     if (loaderActive || !exitDone) {
-        return (jsx(AcademeLoading, { loading: loaderActive, duration: 1200, onFinish: () => setExitDone(true), style: { width: "100vw", height: "100vh" } }));
+        return (jsx(AcademeLoading, { loading: loaderActive, duration: 1200, theme: theme, onFinish: () => setExitDone(true), style: { width: "100vw", height: "100vh" } }));
     }
     return (jsx(ProtectedAppContext.Provider, { value: textColors, children: children }));
 };