track-cli 4.0.3 → 4.1.0-rc1

package/esm/src/action/clone.js

@@ -8,9 +8,9 @@ import { TrainingClient } from "../track/training.js";
 import { exists } from "../../deps/deno.land/std@0.195.0/fs/mod.js";
 export async function clone(url, options) {
     // console.log(`url: ${url}`);
-    // console.log(`target_dir: ${targetDir}`);
-    // console.log(`basicAuthUser: ${basicAuthUser}`);
-    // console.log(`basicAuthPassword: ${basicAuthPassword}`);
+    // console.log(`target_dir: ${options.targetDir}`);
+    // console.log(`basicAuthUser: ${options.basicAuthUser}`);
+    // console.log(`basicAuthPassword: ${options.basicAuthPassword}`);
     const cloneUrl = new CloneUrl(url);
     const basicAuth = options?.basicAuthUser
         ? {
@@ -55,6 +55,7 @@ export async function clone(url, options) {
         token: cloneUrl.token,
         cookies: api.getCookies(),
         programmingLanguage: result.programmingLanguage,
+        frontendTemplate: codingContext.selectedFrontendTemplate?.seriesCode,
     });
     await config.save(trackConfig, {
         path: `${challengeDir}/.track/config.json`,

package/esm/src/action/frontend-template-switch.d.ts

@@ -0,0 +1 @@
+export declare function switchFrontendTemplate(): Promise<void>;

package/esm/src/action/frontend-template-switch.js

@@ -0,0 +1,56 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { load as loadConfig, save as saveConfig, } from "../shared/config.js";
+import { OtherError } from "../shared/errors.js";
+import { ChallengeStyle } from "../shared/types.js";
+import { archiveExistingChallengeFiles, chooseFrontendTemplate, getCommonChallengeContext, trackClientFromConfig, } from "../shared/mod.js";
+import { unzip } from "../shared/file.js";
+export async function switchFrontendTemplate() {
+    const config = await loadConfig();
+    const api = trackClientFromConfig(config);
+    const [codingContext, challenge] = await getCommonChallengeContext(config, api);
+    if (challenge.style !== ChallengeStyle.Frontend) {
+        throw new OtherError("This challenge is not a frontend challenge");
+    }
+    // Get available frontend templates from Track
+    const allFrontendTemplates = await api.frontendTemplates();
+    // Filter by allowed templates for this challenge
+    const allowedCodes = challenge.allowedTemplateSeriesCodes;
+    const availableTemplates = allowedCodes && allowedCodes.length > 0
+        ? allFrontendTemplates.filter((t) => allowedCodes.includes(t.seriesCode))
+        : allFrontendTemplates;
+    if (availableTemplates.length === 0) {
+        throw new OtherError("This challenge does not support changing frontend templates");
+    }
+    console.log("Your existing code will be archived in this directory and the original challenge code for the new template will be downloaded");
+    const shouldContinue = dntShim.confirm("Are you sure you want to continue?");
+    if (!shouldContinue) {
+        return;
+    }
+    const desiredTemplate = chooseFrontendTemplate(availableTemplates);
+    if (desiredTemplate.seriesCode ===
+        codingContext.selectedFrontendTemplate?.seriesCode) {
+        // already using this template
+        return;
+    }
+    // Get template details with presigned URLs
+    const templateDetails = await api.frontendTemplate(desiredTemplate.seriesCode);
+    if (!templateDetails.downloadUrl) {
+        throw new OtherError("Template does not have a download URL available");
+    }
+    const currentDir = dntShim.Deno.cwd();
+    await archiveExistingChallengeFiles(config.orgName);
+    // Download and extract the template ZIP file
+    const templateResp = await dntShim.fetch(templateDetails.downloadUrl);
+    if (!templateResp.ok) {
+        throw new OtherError(`Failed to download template: ${templateResp.status} ${templateResp.statusText}`);
+    }
+    // Extract template files
+    const templateZip = new Uint8Array(await templateResp.arrayBuffer());
+    await unzip(templateZip, currentDir);
+    const updatedConfig = {
+        ...config,
+        frontendTemplate: desiredTemplate.seriesCode,
+    };
+    await saveConfig(updatedConfig);
+    console.debug("Frontend template switch completed.");
+}

package/esm/src/action/frontend-template.d.ts

@@ -0,0 +1,2 @@
+import { FrontendTemplateInfo } from "../shared/types.js";
+export declare function chooseFrontendTemplate(availableTemplates: FrontendTemplateInfo[]): FrontendTemplateInfo;

package/esm/src/action/frontend-template.js

@@ -0,0 +1,12 @@
+import { Prompt } from "../shared/mod.js";
+export function chooseFrontendTemplate(availableTemplates) {
+    while (true) {
+        const desiredTemplateIndex = Prompt.select("Please select a frontend template:", availableTemplates.map((t) => t.seriesName));
+        if (desiredTemplateIndex !== undefined) {
+            return availableTemplates[desiredTemplateIndex];
+        }
+        else {
+            console.log("An invalid frontend template was specified");
+        }
+    }
+}

package/esm/src/main.js

@@ -4,6 +4,7 @@ import * as dntShim from "../_dnt.shims.js";
 import { clone as cloneAction } from "./action/clone.js";
 import { run as runAction } from "./action/run.js";
 import { lang as langAction } from "./action/lang.js";
+import { switchFrontendTemplate as frontendTemplateAction } from "./action/frontend-template-switch.js";
 import { reset as resetAction } from "./action/reset.js";
 import { pull as pullAction } from "./action/pull.js";
 import { add as addAction } from "./action/add.js";
@@ -37,6 +38,11 @@ import { Command } from "../deps/deno.land/x/cliffy@v0.25.7/command/mod.js";
         .action(async () => {
         await langAction();
     });
+    const frontendTemplateCommand = new Command()
+        .description("Change the frontend template used for this challenge.")
+        .action(async () => {
+        await frontendTemplateAction();
+    });
     const resetCommand = new Command()
         .description("Reset the challenge files back to their starting point and archive your current challenge files.")
         .action(async () => {
@@ -65,7 +71,7 @@ import { Command } from "../deps/deno.land/x/cliffy@v0.25.7/command/mod.js";
         .action(async () => {
         await statusAction();
     });
-    if (!await checkUpdates()) {
+    if (!(await checkUpdates())) {
         dntShim.Deno.exit(1);
     }
     await new Command()
@@ -78,6 +84,7 @@ import { Command } from "../deps/deno.land/x/cliffy@v0.25.7/command/mod.js";
         .command("clone", cloneCommand)
         .command("run", runCommand)
         .command("lang", langCommand)
+        .command("frontend-template", frontendTemplateCommand)
         .command("reset", resetCommand)
         .command("pull", pullCommand)
         .command("add", addCommand)
@@ -87,7 +94,7 @@ import { Command } from "../deps/deno.land/x/cliffy@v0.25.7/command/mod.js";
     dntShim.Deno.exit(0);
 })().catch((err) => {
     if (err instanceof TrackError) {
-        console.error(`${red("[ERROR]")} ${err.message}`);
+        console.error(`${red("[ERROR]")} ${"message" in err ? String(err.message) : String(err)}`);
         dntShim.Deno.exit(1);
     }
     else {

package/esm/src/meta.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "4.0.3";
+export declare const VERSION = "4.1.0-rc1";
 export declare const DESCRIPTION = "A CLI for interacting with tracks.run and running code tests on track's servers";
 export declare function checkUpdates(): Promise<boolean>;

package/esm/src/meta.js

@@ -1,7 +1,7 @@
 import * as colors from "../deps/deno.land/std@0.195.0/fmt/colors.js";
 // @ts-ignore: has no exported member
 import { CookieJar, fetch } from "node-fetch-cookies";
-export const VERSION = "4.0.3";
+export const VERSION = "4.1.0-rc1";
 export const DESCRIPTION = "A CLI for interacting with tracks.run and running code tests on track's servers";
 const VERSION_RE = /^(\d+)\.(\d+)\.(\d+)(?:-?(.*))$/;
 function parseSemver(s) {
@@ -9,43 +9,126 @@ function parseSemver(s) {
     if (!match) {
         return;
     }
-    return [
-        parseInt(match[1]),
-        parseInt(match[2]),
-        parseInt(match[3]),
-        match[4],
-    ];
+    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3]), match[4]];
 }
 export async function checkUpdates() {
     const res = await fetch(new CookieJar(), "https://track-cli.s3-ap-northeast-1.amazonaws.com/version.json");
     const publishedVersion = await res.json();
-    const supportedFrom = parseSemver(publishedVersion.supported_from) ??
-        [1, 0, 0, ""];
+    const supportedFrom = parseSemver(publishedVersion.supported_from) ?? [
+        1,
+        0,
+        0,
+        "",
+    ];
     const latest = parseSemver(publishedVersion.latest) ?? [1, 0, 0, ""];
     const current = parseSemver(VERSION);
-    // deno-fmt-ignore
     if (parseSemver(VERSION) < supportedFrom) {
-        console.log("╭─────────────────────────────────────────────────────────────────────────────────────────────╮");
-        console.log("|                                                                                             |");
-        console.log(`|                                      ${colors.bold(colors.red("!!! OUTDATED !!!"))}                                       |`);
-        console.log("|                       This version of Track CLI is no more supported.                       |");
-        console.log(`|                                  Current version: ${VERSION.padEnd(20)}                      |`);
-        console.log(`|                                  Latest version:  ${publishedVersion.latest.padEnd(20)}                      |`);
-        console.log("|                                                                                             |");
-        console.log("╰─────────────────────────────────────────────────────────────────────────────────────────────╯");
+        new Box({ width: 95 }).printBox([
+            { center: true },
+            [
+                applyFormatting("!!! OUTDATED !!!", (s) => colors.bold(colors.red(s))),
+            ],
+        ], [{ left: 22 }, ["This version of Track CLI is no longer supported."]], [{ left: 22 + 11 }, [`Installed version: ${VERSION}`]], [{ left: 22 + 11 }, [`   Latest version: ${publishedVersion.latest}`]]);
         return false;
     }
     else if (current < latest) {
-        console.log("╭─────────────────────────────────────────────────────────────────────────────────────────────╮");
-        console.log("|                                                                                             |");
-        console.log("|                           New version of Track CLI is available!                            |");
-        console.log(`|                                  Current version: ${VERSION.padEnd(20)}                      |`);
-        console.log(`|                                  Latest version:  ${publishedVersion.latest.padEnd(20)}                      |`);
-        console.log("|                                                                                             |");
-        console.log("╰─────────────────────────────────────────────────────────────────────────────────────────────╯");
+        new Box({ width: 95 }).printBox([{ left: 22 }, ["A new version of Track CLI is available!"]], [{ left: 22 + 11 }, [`Installed version: ${VERSION}`]], [{ left: 22 + 11 }, [`   Latest version: ${publishedVersion.latest}`]]);
         return true;
     }
     else {
         return true;
     }
 }
+function applyFormatting(s, formatting) {
+    return { textWidth: s.length, formatted: formatting(s) };
+}
+class Box {
+    /**
+     * Inclusive of the pipes and the 1 space padding on each side:
+     * `"| content |"` has width 11.
+     */
+    constructor(p) {
+        Object.defineProperty(this, "p", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: p
+        });
+    }
+    print(message) {
+        console.log(message);
+    }
+    printBox(...lines) {
+        this.printTop();
+        this.printLine({ left: 0 }, [""]);
+        for (const [align, content] of lines) {
+            this.printLine(align, content);
+        }
+        this.printLine({ left: 0 }, [""]);
+        this.printBottom();
+    }
+    printTop() {
+        const message = Box.CORNERS[0][0] +
+            Box.HORIZONTAL.repeat(this.p.width - 2) +
+            Box.CORNERS[0][1];
+        this.print(message);
+    }
+    printBottom() {
+        const message = Box.CORNERS[1][0] +
+            Box.HORIZONTAL.repeat(this.p.width - 2) +
+            Box.CORNERS[1][1];
+        this.print(message);
+    }
+    printLine(align, content) {
+        let contentWidth = 0;
+        const parts = [];
+        for (const part of content) {
+            if (typeof part === "string") {
+                contentWidth += part.length;
+                parts.push(part);
+            }
+            else {
+                contentWidth += part.textWidth;
+                parts.push(part.formatted);
+            }
+        }
+        const innerWidth = this.p.width - 4;
+        let leftPadding = 0;
+        if (align.center) {
+            leftPadding = Math.max(0, Math.floor((innerWidth - contentWidth) / 2));
+        }
+        else if (align.left !== undefined) {
+            leftPadding = align.left;
+        }
+        const rightPadding = innerWidth - leftPadding - contentWidth;
+        const message = [
+            Box.PIPE,
+            " ".repeat(1 + leftPadding),
+            ...parts,
+            rightPadding > 0 ? " ".repeat(rightPadding + 1) : "",
+            rightPadding >= 0 ? Box.PIPE : "",
+        ].join("");
+        this.print(message);
+    }
+}
+Object.defineProperty(Box, "PIPE", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "|"
+});
+Object.defineProperty(Box, "HORIZONTAL", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "─"
+});
+Object.defineProperty(Box, "CORNERS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        ["╭", "╮"],
+        ["╰", "╯"],
+    ]
+});

package/esm/src/orca/client.js

@@ -128,7 +128,7 @@ export class OrcaClient {
                 }));
             }
             catch (e) {
-                rej(new OtherError(e.message));
+                rej(new OtherError(e && typeof e === "object" && "message" in e ? String(e.message) : String(e)));
             }
         });
     }

package/esm/src/shared/config.d.ts

@@ -8,6 +8,7 @@ export interface TrackConfigCore {
     basicAuth?: BasicAuth;
     token: string;
     programmingLanguage?: ProgrammingLanguage;
+    frontendTemplate?: string;
     cookies: Record<string, string>;
 }
 export interface TrackTestConfigPart {

package/esm/src/shared/file.d.ts

@@ -24,6 +24,7 @@ export declare function getAllDirFiles(p: string): Promise<string[]>;
 export declare function toNixStyle(p: string): string;
 export declare function toNativeStyle(p: string): string;
 export declare function untgz(compressed: Uint8Array, dest: string): Promise<void>;
+export declare function unzip(zipData: Uint8Array, dest: string): Promise<void>;
 export type GetUniqueDirNameOptions = {
     root?: string;
 };

package/esm/src/shared/file.js

@@ -97,6 +97,38 @@ export async function untgz(compressed, dest) {
         cwd: dest,
     });
 }
+export async function unzip(zipData, dest) {
+    const JSZip = (await import("jszip")).default;
+    try {
+        // destination directory exists
+        await fs.ensureDir(dest);
+        const zip = new JSZip();
+        await zip.loadAsync(zipData);
+        const promises = [];
+        zip.forEach((relativePath, file) => {
+            if (!file.dir) {
+                // file
+                promises.push((async () => {
+                    const content = await file.async("uint8array");
+                    const filePath = path.join(dest, relativePath);
+                    await fs.ensureFile(filePath);
+                    await dntShim.Deno.writeFile(filePath, content);
+                })());
+            }
+            else {
+                // directory
+                promises.push((async () => {
+                    const dirPath = path.join(dest, relativePath);
+                    await fs.ensureDir(dirPath);
+                })());
+            }
+        });
+        await Promise.all(promises);
+    }
+    catch (error) {
+        throw new Error(`Failed to extract ZIP file: ${error}`);
+    }
+}
 export async function getUniqueDirName(base, options) {
     let counter = 1;
     const root = options?.root ?? dntShim.Deno.cwd();

package/esm/src/shared/mod.d.ts

@@ -39,5 +39,5 @@ export type ArchiveExistingChallengeFilesOptions = {
     selectedLanguage?: ProgrammingLanguageInfo;
 };
 export declare function archiveExistingChallengeFiles(orgName: string): Promise<void>;
+export { chooseFrontendTemplate } from "../action/frontend-template.js";
 export declare function trackClientFromConfig(config: TrackConfig): TrackClient;
-export {};

package/esm/src/shared/mod.js

@@ -2,7 +2,7 @@ import * as dntShim from "../../_dnt.shims.js";
 import { save as saveConfig, } from "./config.js";
 import { BadTarballURL, ChallengeAlreadyFinished, OtherError, } from "./errors.js";
 import { toNativeStyle, untgz } from "./file.js";
-import { ChallengeResultStatus, FileListType, TrackApp, } from "./types.js";
+import { ChallengeResultStatus, ChallengeStyle, FileListType, TrackApp, } from "./types.js";
 import { TestClient } from "../track/test.js";
 import { TrainingClient } from "../track/training.js";
 import * as datetime from "../../deps/deno.land/std@0.195.0/datetime/mod.js";
@@ -100,6 +100,13 @@ export async function tryStartingChallenge(api, challenge) {
                             await api.updateLanguage(desiredLanguage.value);
                         }
                     }
+                    // Handle template selection for frontend challenges
+                    if (challenge.style === ChallengeStyle.Frontend) {
+                        const frontendTemplates = await api.frontendTemplates();
+                        if (frontendTemplates.length > 0) {
+                            console.log("Frontend challenge detected. Use 'track frontend-template' to switch templates after cloning.");
+                        }
+                    }
                     result = await api.start();
                     break;
                 }
@@ -354,11 +361,12 @@ export /**
         await fs.move(`${challengeDir}/${dirEntry.name}`, `${archiveDir}/${dirEntry.name}`);
     }
 }
+export { chooseFrontendTemplate } from "../action/frontend-template.js";
 export function trackClientFromConfig(config) {
     let api;
     switch (config.app) {
         case TrackApp.Test:
-            api = new TestClient(config.baseUrl, config.orgName, config.token, config.challengeId, config.basicAuth, config.cookies);
+            api = new TestClient(config.baseUrl, config.orgName, config.token, config.challengeId, config.basicAuth, config.cookies, config.applicantExamId, config.challengeResultId);
             break;
         case TrackApp.Training:
             api = new TrainingClient(config.baseUrl, config.orgName, config.token, config.courseMaterialId, config.klassId, config.klassResultId, config.basicAuth, config.cookies);

package/esm/src/shared/types.d.ts

@@ -25,6 +25,7 @@ export interface ChallengeSession {
     timeLimitMinutes?: number;
     displayOrder: number;
     programmingLanguages: ProgrammingLanguage[];
+    allowedTemplateSeriesCodes?: string[];
     localCodingAllowed: boolean;
     openTestcases?: number;
     result?: ChallengeResult;
@@ -59,6 +60,8 @@ export interface CodingContext {
     allowEdit?: boolean;
     programmingLanguages: ProgrammingLanguage[];
     selectedLanguage?: ProgrammingLanguage;
+    selectedFrontendTemplate?: FrontendTemplateInfo;
+    availableFrontendTemplates?: FrontendTemplateInfo[];
     challengeLanguage: SpokenLanguage;
     settings: ChallengeSettings;
     answers: CodingAnswers;
@@ -122,6 +125,7 @@ export declare const ChallengeStyle: {
     readonly Development: 2;
     readonly Algorithm: 3;
     readonly Ai: 4;
+    readonly Frontend: 8;
 };
 export type ChallengeStyle = (typeof ChallengeStyle)[keyof typeof ChallengeStyle];
 export declare const ChallengeResultStatus: {
@@ -140,3 +144,14 @@ export declare const SpokenLanguage: {
 };
 export type SpokenLanguage = (typeof SpokenLanguage)[keyof typeof SpokenLanguage];
 export type ProgrammingLanguage = number;
+export interface FrontendTemplateInfo {
+    seriesCode: string;
+    seriesName: string;
+    versionId: number;
+    versionName: string;
+    downloadUrl?: string;
+    readmeUrl?: {
+        en?: string;
+        ja?: string;
+    };
+}

package/esm/src/shared/types.js

@@ -84,6 +84,7 @@ export const ChallengeStyle = {
     Development: 2,
     Algorithm: 3,
     Ai: 4,
+    Frontend: 8,
 };
 export const ChallengeResultStatus = {
     Prepared: 0,

package/esm/src/track/client.d.ts

@@ -1,6 +1,6 @@
 import * as dntShim from "../../_dnt.shims.js";
 import { TrackTestConfigPart, TrackTrainingConfigPart } from "../shared/config.js";
-import { ChallengeResult, ChallengeSession, CodingContext, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
+import { ChallengeResult, ChallengeSession, CodingContext, FrontendTemplateInfo, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
 import { CookieJar } from "node-fetch-cookies";
 import { ProxyAgent } from "proxy-agent";
 export interface BasicAuth {
@@ -41,9 +41,12 @@ export interface TrackClient {
     };
     startChallengeSession(): Promise<ChallengeSession>;
     languages(): Promise<ProgrammingLanguageInfo[]>;
+    frontendTemplates(): Promise<FrontendTemplateInfo[]>;
+    frontendTemplate(code: string): Promise<FrontendTemplateInfo>;
     start(): Promise<ChallengeResult>;
     prepare(): Promise<ChallengeResult>;
     updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    updateFrontendTemplate(templateCode: string): Promise<void>;
     timeLeft(): Promise<number>;
     context(): Promise<CodingContext>;
     presigned(files: string[]): Promise<{

package/esm/src/track/test.d.ts

@@ -1,5 +1,5 @@
 import { TrackTestConfigPart } from "../shared/config.js";
-import { ChallengeResult, ChallengeSession, CodingContext, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
+import { ChallengeResult, ChallengeSession, CodingContext, FrontendTemplateInfo, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
 import { BasicAuth, TrackClient, TrackClientBase } from "./client.js";
 export declare class TestClient extends TrackClientBase implements TrackClient {
     private orgName;
@@ -7,7 +7,7 @@ export declare class TestClient extends TrackClientBase implements TrackClient {
     private challengeId;
     private applicantExamId;
     private resultId;
-    constructor(baseUrl: string, orgName: string, token: string, challengeId: number, basic?: BasicAuth, cookies?: Record<string, string>);
+    constructor(baseUrl: string, orgName: string, token: string, challengeId: number, basic?: BasicAuth, cookies?: Record<string, string>, applicantExamId?: number, challengeResultId?: number);
     config(): TrackTestConfigPart;
     authenticate(): Promise<void>;
     startChallengeSession(): Promise<ChallengeSession>;
@@ -16,9 +16,12 @@ export declare class TestClient extends TrackClientBase implements TrackClient {
     private getExamSession;
     private getChallengeFromExamSession;
     languages(): Promise<ProgrammingLanguageInfo[]>;
+    frontendTemplates(): Promise<FrontendTemplateInfo[]>;
+    frontendTemplate(code: string): Promise<FrontendTemplateInfo>;
     start(): Promise<ChallengeResult>;
     prepare(): Promise<ChallengeResult>;
     updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    updateFrontendTemplate(templateCode: string): Promise<void>;
     timeLeft(): Promise<number>;
     context(): Promise<CodingContext>;
     presigned(files: string[]): Promise<{

package/esm/src/track/test.js

@@ -5,7 +5,7 @@ import { FormType, TrackClientBase, } from "./client.js";
 // @ts-ignore: has no exported member
 import { CookieJar, fetch } from "node-fetch-cookies";
 export class TestClient extends TrackClientBase {
-    constructor(baseUrl, orgName, token, challengeId, basic, cookies) {
+    constructor(baseUrl, orgName, token, challengeId, basic, cookies, applicantExamId, challengeResultId) {
         super(baseUrl, basic, cookies);
         Object.defineProperty(this, "orgName", {
             enumerable: true,
@@ -40,6 +40,8 @@ export class TestClient extends TrackClientBase {
         this.orgName = orgName;
         this.token = token;
         this.challengeId = challengeId;
+        this.applicantExamId = applicantExamId ?? 0;
+        this.resultId = challengeResultId ?? 0;
     }
     config() {
         return {
@@ -100,12 +102,19 @@ export class TestClient extends TrackClientBase {
             .map((esc) => toChallengeSession(esc, result))
             .find((c) => c.challengeId === this.challengeId &&
             (c.style === ChallengeStyle.Development ||
-                c.style === ChallengeStyle.Algorithm));
+                c.style === ChallengeStyle.Algorithm ||
+                c.style === ChallengeStyle.Frontend));
     }
     async languages() {
         return (await this._get(`/api/enum/challenges/programminglanguages`))
             .map(toProgrammingLanguageInfo);
     }
+    async frontendTemplates() {
+        return await this._get(`/api/dock-public/v2/consumer/frontend-templates`);
+    }
+    async frontendTemplate(code) {
+        return await this._get(`/api/dock-public/v2/consumer/frontend-templates/${code}`);
+    }
     async start() {
         return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/start`, FormType.URLEncoded, {
             takenBy: 3, // 3 = LocalMachine
@@ -121,6 +130,11 @@ export class TestClient extends TrackClientBase {
             programmingLanguage: language,
         }); // ChallengeResult
     }
+    async updateFrontendTemplate(templateCode) {
+        return await this._put(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/frontend-template`, FormType.URLEncoded, {
+            frontendTemplate: templateCode,
+        });
+    }
     async timeLeft() {
         return await this._get(`/api/applicants/exams/${this.applicantExamId}/results/${this.resultId}/timeleft`);
     }
@@ -171,6 +185,8 @@ function toChallengeSession(esc, result) {
         timeLimitMinutes: esc.timeLimitMinutes,
         displayOrder: esc.displayOrder,
         programmingLanguages: esc.programmingLanguages,
+        allowedTemplateSeriesCodes: esc.frontendStyleConfig
+            ?.allowedTemplateSeriesCodes,
         localCodingAllowed: esc.localExamEnabled,
         openTestcases: esc.openTestcases,
         result,

package/esm/src/track/training.d.ts

@@ -1,5 +1,5 @@
 import { TrackTrainingConfigPart } from "../shared/config.js";
-import { ChallengeResult, ChallengeSession, CodingContext, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
+import { ChallengeResult, ChallengeSession, CodingContext, FrontendTemplateInfo, ProgrammingLanguage, ProgrammingLanguageInfo, SaveFilesRequest } from "../shared/types.js";
 import { BasicAuth, TrackClient, TrackClientBase } from "./client.js";
 export declare class TrainingClient extends TrackClientBase implements TrackClient {
     private orgName;
@@ -13,9 +13,12 @@ export declare class TrainingClient extends TrackClientBase implements TrackClie
     startChallengeSession(): Promise<ChallengeSession>;
     continueChallengeSession(): Promise<ChallengeSession>;
     languages(): Promise<ProgrammingLanguageInfo[]>;
+    frontendTemplates(): Promise<FrontendTemplateInfo[]>;
+    frontendTemplate(_code: string): Promise<FrontendTemplateInfo>;
     start(): Promise<ChallengeResult>;
     prepare(): Promise<ChallengeResult>;
     updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    updateFrontendTemplate(_templateCode: string): Promise<void>;
     timeLeft(): Promise<number>;
     context(): Promise<CodingContext>;
     presigned(files: string[]): Promise<{

package/esm/src/track/training.js

@@ -74,6 +74,12 @@ export class TrainingClient extends TrackClientBase {
         return (await this._get(`/cli/languages`))
             .map(toProgrammingLanguageInfo);
     }
+    frontendTemplates() {
+        throw new OtherError("Frontend templates are not supported in training mode");
+    }
+    frontendTemplate(_code) {
+        throw new OtherError("Frontend templates are not supported in training mode");
+    }
     async start() {
         return await this._put(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/start`, FormType.JSON, {
             takenBy: 3, // 3 = LocalMachine
@@ -87,6 +93,9 @@ export class TrainingClient extends TrackClientBase {
             lang: language,
         });
     }
+    updateFrontendTemplate(_templateCode) {
+        throw new OtherError("Frontend templates are not supported in training mode");
+    }
     async timeLeft() {
         return await this._get(`/api/train/${this.klassId}/challenges/results/${this.klassResultId}/timeleft`);
     }

package/esm/test/shared/config_test.d.ts

@@ -0,0 +1 @@
+export {};