track-cli 4.0.3 → 4.1.0-rc2

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,53 @@
+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 { archiveExistingChallengeFiles, chooseFrontendTemplate, downloadChallengeFilesTo, getCommonChallengeContext, trackClientFromConfig, } from "../shared/mod.js";
+import { ChallengeStyle } from "../shared/types.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 Framework (VSCode) challenge." +
+            "\n\thint: Use 'track lang' to change programming language instead.");
+    }
+    // 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) {
+        const shouldForceReset = dntShim.confirm(`You are already using the template '${desiredTemplate.seriesCode}'. Do you want to start-over from the template code anyway?`);
+        if (!shouldForceReset) {
+            // already using this template
+            return;
+        }
+    }
+    await archiveExistingChallengeFiles(config.orgName);
+    // Ask the backend to reset the user's solution to the starter code for this template.
+    await api.updateFrontendTemplate(desiredTemplate.seriesCode);
+    // Re-download the challenge files to reflect the reset solution in the backend.
+    const currentDir = dntShim.Deno.cwd();
+    const newCodingContext = await api.context();
+    const showFileDiff = false;
+    const includeTarball = false;
+    await downloadChallengeFilesTo(newCodingContext, currentDir, api, showFileDiff, includeTarball);
+    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/action/lang.js

@@ -2,15 +2,24 @@ import * as dntShim from "../../_dnt.shims.js";
 import { load as loadConfig, save as saveConfig, } from "../shared/config.js";
 import { CantChooseLanguage } from "../shared/errors.js";
 import { archiveExistingChallengeFiles, chooseProgrammingLanguage, downloadChallengeFilesTo, getCommonChallengeContext, trackClientFromConfig, } from "../shared/mod.js";
+import { ChallengeStyle, } from "../shared/types.js";
 export async function lang() {
     const config = await loadConfig();
     const api = trackClientFromConfig(config);
     const [codingContext, challenge] = await getCommonChallengeContext(config, api);
     if (challenge.programmingLanguages.length === 0) {
-        throw new CantChooseLanguage();
+        throw new CantChooseLanguage({
+            hint: challenge.style === ChallengeStyle.Frontend
+                ? "Use 'track frontend-template' to change the frontend template for a Frontend Framework (VSCode) challenge."
+                : "",
+        });
     }
     const availableLanguages = (await api.languages())
-        .filter((pl) => codingContext.programmingLanguages.find((n) => n === pl.value));
+        .filter((pl) => {
+        return codingContext.programmingLanguages.find((n) => {
+            return n === pl.value;
+        });
+    });
     console.log("Your existing code will be archived in this directory and the original challenge code for the new language will be downloaded");
     const shouldContinue = dntShim.confirm("Are you sure you want to continue?");
     if (!shouldContinue) {

package/esm/src/action/run.js

@@ -59,17 +59,16 @@ export async function run(options) {
     const runId = dntShim.crypto.randomUUID();
     // Run the initialize/build commands if they exist
     let buildDoneData;
-    if ((codingContext.answers.build?.length || 0) > 0 ||
-        codingContext.settings.initialize.length > 0) {
-        const shellCommand = []
-            .concat(codingContext.settings.initialize)
-            .concat(codingContext.answers.build || [])
-            .filter((s) => s && s.length > 0);
+    const buildCommands = []
+        .concat(codingContext.settings.initialize || [])
+        .concat(codingContext.answers.build || [])
+        .filter((s) => s && s.length > 0);
+    if (buildCommands.length > 0) {
         const runCmd = {
             id: `${runId}-build`,
             imageName: envConfig.imageName,
             workingDir: envConfig.workingDir ?? "",
-            shellCmd: shellCommand.join(" && "),
+            shellCmd: buildCommands.join(" && "),
             attachVolume: true,
             files,
             envVars: {},

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-rc2";
 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-rc2";
 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/errors.d.ts

@@ -47,8 +47,14 @@ export declare class InvalidChallengeId extends TrackError {
     challengeId: number;
     constructor(challengeId: number);
 }
+export declare class UnsupportedChallenge extends TrackError {
+    challengeId: number;
+    constructor(challengeId: number);
+}
 export declare class CantChooseLanguage extends TrackError {
-    constructor();
+    constructor(p?: {
+        hint?: string;
+    });
 }
 export declare class NotASingleResponse extends TrackError {
     constructor();

package/esm/src/shared/errors.js

@@ -119,7 +119,7 @@ export class ChallengeAlreadyFinished extends TrackError {
 }
 export class InvalidChallengeId extends TrackError {
     constructor(challengeId) {
-        super(`The challenge id specified in your URL (${challengeId}), is invalid`);
+        super(`The challenge id specified in your URL (${challengeId}) is invalid`);
         Object.defineProperty(this, "challengeId", {
             enumerable: true,
             configurable: true,
@@ -129,9 +129,22 @@ export class InvalidChallengeId extends TrackError {
         this.name = "InvalidChallengeId";
     }
 }
+export class UnsupportedChallenge extends TrackError {
+    constructor(challengeId) {
+        super(`The challenge id specified in your URL (${challengeId}) is not supported by the 'track' CLI`);
+        Object.defineProperty(this, "challengeId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: challengeId
+        });
+        this.name = "UnsupportedChallenge";
+    }
+}
 export class CantChooseLanguage extends TrackError {
-    constructor() {
-        super("This challenge does not support changing programming languages");
+    constructor(p = {}) {
+        super("This challenge does not support changing programming languages." +
+            (p.hint ? `\n\thint: ${p.hint}` : ""));
         this.name = "CantChooseLanguage";
     }
 }

package/esm/src/shared/file.js

@@ -1,8 +1,8 @@
 import * as dntShim from "../../_dnt.shims.js";
-import * as path from "../../deps/deno.land/std@0.195.0/path/mod.js";
 import { Foras, gunzip } from "@hazae41/foras";
 import tar from "tar";
 import * as fs from "../../deps/deno.land/std@0.195.0/fs/mod.js";
+import * as path from "../../deps/deno.land/std@0.195.0/path/mod.js";
 export const _internals = {
     SEP: path.SEP,
 };

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;
@@ -121,7 +124,9 @@ export declare const ChallengeStyle: {
     readonly Quiz: 1;
     readonly Development: 2;
     readonly Algorithm: 3;
+    readonly Function: 7;
     readonly Ai: 4;
+    readonly Frontend: 8;
 };
 export type ChallengeStyle = (typeof ChallengeStyle)[keyof typeof ChallengeStyle];
 export declare const ChallengeResultStatus: {
@@ -140,3 +145,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

@@ -83,7 +83,9 @@ export const ChallengeStyle = {
     Quiz: 1,
     Development: 2,
     Algorithm: 3,
+    Function: 7,
     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>;
@@ -15,10 +15,14 @@ export declare class TestClient extends TrackClientBase implements TrackClient {
     private ensureExamInProgress;
     private getExamSession;
     private getChallengeFromExamSession;
+    isChallengeSupported(c: ChallengeSession): boolean;
     languages(): Promise<ProgrammingLanguageInfo[]>;
+    frontendTemplates(): Promise<FrontendTemplateInfo[]>;
+    frontendTemplate(code: string): Promise<FrontendTemplateInfo>;
     start(): Promise<ChallengeResult>;
     prepare(): Promise<ChallengeResult>;
     updateLanguage(language: ProgrammingLanguage): Promise<void>;
+    updateFrontendTemplate(seriesCode: string): Promise<void>;
     timeLeft(): Promise<number>;
     context(): Promise<CodingContext>;
     presigned(files: string[]): Promise<{