track-cli 3.0.0-rc

package/esm/deps/deno.land/x/cliffy@v0.25.7/table/table.d.ts

@@ -0,0 +1,135 @@
+import { IBorder } from "./border.js";
+import { Direction } from "./cell.js";
+import { IDataRow, IRow, Row } from "./row.js";
+/** Border characters settings. */
+export type IBorderOptions = Partial<IBorder>;
+/** Table options. */
+export interface ITableOptions {
+    indent?: number;
+    border?: boolean;
+    align?: Direction;
+    maxColWidth?: number | number[];
+    minColWidth?: number | number[];
+    padding?: number | number[];
+    chars?: IBorderOptions;
+}
+/** Table settings. */
+export interface ITableSettings extends Required<Omit<ITableOptions, "align">> {
+    chars: IBorder;
+    align?: Direction;
+}
+/** Table type. */
+export type ITable<T extends IRow = IRow> = T[] | Table<T>;
+/** Table representation. */
+export declare class Table<T extends IRow = IRow> extends Array<T> {
+    protected static _chars: IBorder;
+    protected options: ITableSettings;
+    private headerRow?;
+    /**
+     * Create a new table. If rows is a table, all rows and options of the table
+     * will be copied to the new table.
+     * @param rows
+     */
+    static from<T extends IRow>(rows: ITable<T>): Table<T>;
+    /**
+     * Create a new table from an array of json objects. An object represents a
+     * row and each property a column.
+     * @param rows Array of objects.
+     */
+    static fromJson(rows: IDataRow[]): Table;
+    /**
+     * Set global default border characters.
+     * @param chars Border options.
+     */
+    static chars(chars: IBorderOptions): typeof Table;
+    /**
+     * Write table or rows to stdout.
+     * @param rows Table or rows.
+     */
+    static render<T extends IRow>(rows: ITable<T>): void;
+    /**
+     * Read data from an array of json objects. An object represents a
+     * row and each property a column.
+     * @param rows Array of objects.
+     */
+    fromJson(rows: IDataRow[]): this;
+    /**
+     * Set table header.
+     * @param header Header row or cells.
+     */
+    header(header: IRow): this;
+    /**
+     * Set table body.
+     * @param rows Table rows.
+     */
+    body(rows: T[]): this;
+    /** Clone table recursively with header and options. */
+    clone(): Table;
+    /** Generate table string. */
+    toString(): string;
+    /** Write table to stdout. */
+    render(): this;
+    /**
+     * Set max col with.
+     * @param width     Max col width.
+     * @param override  Override existing value.
+     */
+    maxColWidth(width: number | number[], override?: boolean): this;
+    /**
+     * Set min col width.
+     * @param width     Min col width.
+     * @param override  Override existing value.
+     */
+    minColWidth(width: number | number[], override?: boolean): this;
+    /**
+     * Set table indentation.
+     * @param width     Indent width.
+     * @param override  Override existing value.
+     */
+    indent(width: number, override?: boolean): this;
+    /**
+     * Set cell padding.
+     * @param padding   Cell padding.
+     * @param override  Override existing value.
+     */
+    padding(padding: number | number[], override?: boolean): this;
+    /**
+     * Enable/disable cell border.
+     * @param enable    Enable/disable cell border.
+     * @param override  Override existing value.
+     */
+    border(enable: boolean, override?: boolean): this;
+    /**
+     * Align table content.
+     * @param direction Align direction.
+     * @param override  Override existing value.
+     */
+    align(direction: Direction, override?: boolean): this;
+    /**
+     * Set border characters.
+     * @param chars Border options.
+     */
+    chars(chars: IBorderOptions): this;
+    /** Get table header. */
+    getHeader(): Row | undefined;
+    /** Get table body. */
+    getBody(): T[];
+    /** Get mac col widrth. */
+    getMaxColWidth(): number | number[];
+    /** Get min col width. */
+    getMinColWidth(): number | number[];
+    /** Get table indentation. */
+    getIndent(): number;
+    /** Get cell padding. */
+    getPadding(): number | number[];
+    /** Check if table has border. */
+    getBorder(): boolean;
+    /** Check if header row has border. */
+    hasHeaderBorder(): boolean;
+    /** Check if table bordy has border. */
+    hasBodyBorder(): boolean;
+    /** Check if table header or body has border. */
+    hasBorder(): boolean;
+    /** Get table alignment. */
+    getAlign(): Direction;
+}

package/esm/deps/deno.land/x/cliffy@v0.25.7/table/table.js

@@ -0,0 +1,237 @@
+import { border } from "./border.js";
+import { Cell } from "./cell.js";
+import { TableLayout } from "./layout.js";
+import { Row } from "./row.js";
+/** Table representation. */
+class Table extends Array {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                indent: 0,
+                border: false,
+                maxColWidth: Infinity,
+                minColWidth: 0,
+                padding: 1,
+                chars: { ...Table._chars },
+            }
+        });
+        Object.defineProperty(this, "headerRow", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    /**
+     * Create a new table. If rows is a table, all rows and options of the table
+     * will be copied to the new table.
+     * @param rows
+     */
+    static from(rows) {
+        const table = new this(...rows);
+        if (rows instanceof Table) {
+            table.options = { ...rows.options };
+            table.headerRow = rows.headerRow ? Row.from(rows.headerRow) : undefined;
+        }
+        return table;
+    }
+    /**
+     * Create a new table from an array of json objects. An object represents a
+     * row and each property a column.
+     * @param rows Array of objects.
+     */
+    static fromJson(rows) {
+        return new this().fromJson(rows);
+    }
+    /**
+     * Set global default border characters.
+     * @param chars Border options.
+     */
+    static chars(chars) {
+        Object.assign(this._chars, chars);
+        return this;
+    }
+    /**
+     * Write table or rows to stdout.
+     * @param rows Table or rows.
+     */
+    static render(rows) {
+        Table.from(rows).render();
+    }
+    /**
+     * Read data from an array of json objects. An object represents a
+     * row and each property a column.
+     * @param rows Array of objects.
+     */
+    fromJson(rows) {
+        this.header(Object.keys(rows[0]));
+        this.body(rows.map((row) => Object.values(row)));
+        return this;
+    }
+    /**
+     * Set table header.
+     * @param header Header row or cells.
+     */
+    header(header) {
+        this.headerRow = header instanceof Row ? header : Row.from(header);
+        return this;
+    }
+    /**
+     * Set table body.
+     * @param rows Table rows.
+     */
+    body(rows) {
+        this.length = 0;
+        this.push(...rows);
+        return this;
+    }
+    /** Clone table recursively with header and options. */
+    clone() {
+        const table = new Table(...this.map((row) => row instanceof Row ? row.clone() : Row.from(row).clone()));
+        table.options = { ...this.options };
+        table.headerRow = this.headerRow?.clone();
+        return table;
+    }
+    /** Generate table string. */
+    toString() {
+        return new TableLayout(this, this.options).toString();
+    }
+    /** Write table to stdout. */
+    render() {
+        console.log(this.toString());
+        return this;
+    }
+    /**
+     * Set max col with.
+     * @param width     Max col width.
+     * @param override  Override existing value.
+     */
+    maxColWidth(width, override = true) {
+        if (override || typeof this.options.maxColWidth === "undefined") {
+            this.options.maxColWidth = width;
+        }
+        return this;
+    }
+    /**
+     * Set min col width.
+     * @param width     Min col width.
+     * @param override  Override existing value.
+     */
+    minColWidth(width, override = true) {
+        if (override || typeof this.options.minColWidth === "undefined") {
+            this.options.minColWidth = width;
+        }
+        return this;
+    }
+    /**
+     * Set table indentation.
+     * @param width     Indent width.
+     * @param override  Override existing value.
+     */
+    indent(width, override = true) {
+        if (override || typeof this.options.indent === "undefined") {
+            this.options.indent = width;
+        }
+        return this;
+    }
+    /**
+     * Set cell padding.
+     * @param padding   Cell padding.
+     * @param override  Override existing value.
+     */
+    padding(padding, override = true) {
+        if (override || typeof this.options.padding === "undefined") {
+            this.options.padding = padding;
+        }
+        return this;
+    }
+    /**
+     * Enable/disable cell border.
+     * @param enable    Enable/disable cell border.
+     * @param override  Override existing value.
+     */
+    border(enable, override = true) {
+        if (override || typeof this.options.border === "undefined") {
+            this.options.border = enable;
+        }
+        return this;
+    }
+    /**
+     * Align table content.
+     * @param direction Align direction.
+     * @param override  Override existing value.
+     */
+    align(direction, override = true) {
+        if (override || typeof this.options.align === "undefined") {
+            this.options.align = direction;
+        }
+        return this;
+    }
+    /**
+     * Set border characters.
+     * @param chars Border options.
+     */
+    chars(chars) {
+        Object.assign(this.options.chars, chars);
+        return this;
+    }
+    /** Get table header. */
+    getHeader() {
+        return this.headerRow;
+    }
+    /** Get table body. */
+    getBody() {
+        return [...this];
+    }
+    /** Get mac col widrth. */
+    getMaxColWidth() {
+        return this.options.maxColWidth;
+    }
+    /** Get min col width. */
+    getMinColWidth() {
+        return this.options.minColWidth;
+    }
+    /** Get table indentation. */
+    getIndent() {
+        return this.options.indent;
+    }
+    /** Get cell padding. */
+    getPadding() {
+        return this.options.padding;
+    }
+    /** Check if table has border. */
+    getBorder() {
+        return this.options.border === true;
+    }
+    /** Check if header row has border. */
+    hasHeaderBorder() {
+        const hasBorder = this.headerRow?.hasBorder();
+        return hasBorder === true || (this.getBorder() && hasBorder !== false);
+    }
+    /** Check if table bordy has border. */
+    hasBodyBorder() {
+        return this.getBorder() ||
+            this.some((row) => row instanceof Row
+                ? row.hasBorder()
+                : row.some((cell) => cell instanceof Cell ? cell.getBorder : false));
+    }
+    /** Check if table header or body has border. */
+    hasBorder() {
+        return this.hasHeaderBorder() || this.hasBodyBorder();
+    }
+    /** Get table alignment. */
+    getAlign() {
+        return this.options.align ?? "left";
+    }
+}
+Object.defineProperty(Table, "_chars", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: { ...border }
+});
+export { Table };

package/esm/deps/deno.land/x/cliffy@v0.25.7/table/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get next words from the beginning of [content] until all words have a length lower or equal then [length].
+ *
+ * @param length    Max length of all words.
+ * @param content   The text content.
+ */
+import { ICell } from "./cell.js";
+export declare function consumeWords(length: number, content: string): string;
+/**
+ * Get longest cell from given row index.
+ */
+export declare function longest(index: number, rows: ICell[][], maxWidth?: number): number;
+export declare const strLength: (str: string) => number;

package/esm/deps/deno.land/x/cliffy@v0.25.7/table/utils.js

@@ -0,0 +1,60 @@
+/**
+ * Get next words from the beginning of [content] until all words have a length lower or equal then [length].
+ *
+ * @param length    Max length of all words.
+ * @param content   The text content.
+ */
+import { Cell } from "./cell.js";
+import { stripColor } from "./deps.js";
+export function consumeWords(length, content) {
+    let consumed = "";
+    const words = content.split("\n")[0]?.split(/ /g);
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        // consume minimum one word
+        if (consumed) {
+            const nextLength = strLength(word);
+            const consumedLength = strLength(consumed);
+            if (consumedLength + nextLength >= length) {
+                break;
+            }
+        }
+        consumed += (i > 0 ? " " : "") + word;
+    }
+    return consumed;
+}
+/**
+ * Get longest cell from given row index.
+ */
+export function longest(index, rows, maxWidth) {
+    const cellLengths = rows.map((row) => {
+        const cell = row[index];
+        const cellValue = cell instanceof Cell && cell.getColSpan() > 1
+            ? ""
+            : cell?.toString() || "";
+        return cellValue
+            .split("\n")
+            .map((line) => {
+            const str = typeof maxWidth === "undefined"
+                ? line
+                : consumeWords(maxWidth, line);
+            return strLength(str) || 0;
+        });
+    }).flat();
+    return Math.max(...cellLengths);
+}
+export const strLength = (str) => {
+    str = stripColor(str);
+    let length = 0;
+    for (let i = 0; i < str.length; i++) {
+        const charCode = str.charCodeAt(i);
+        // Check for chinese characters: \u4e00 - \u9fa5
+        if (charCode >= 19968 && charCode <= 40869) {
+            length += 2;
+        }
+        else {
+            length += 1;
+        }
+    }
+    return length;
+};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/src/action/add.d.ts

@@ -0,0 +1 @@
+export declare function add(filePaths: string[]): Promise<void>;

package/esm/src/action/add.js

@@ -0,0 +1,57 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { CONFIG_FILE_PATH } from "../shared/config.js";
+import { CantReadFile, NewFilesNotAllowed } from "../shared/errors.js";
+import { pathsToFilenameSet, toNativeStyle } from "../shared/file.js";
+import { getCommonChallengeContext, listFileNames, printWorkingFileSet, } from "../shared/mod.js";
+import { FileListType } from "../track/types.js";
+import * as colors from "../../deps/deno.land/std@0.195.0/fmt/colors.js";
+export async function add(filePaths) {
+    // console.log("add", filePaths);
+    const trackContext = await getCommonChallengeContext();
+    const { config, api, codingContext } = trackContext;
+    if (!codingContext.settings.allowNewFile) {
+        throw new NewFilesNotAllowed();
+    }
+    const requestedPaths = await pathsToFilenameSet(filePaths, {
+        recursive: true,
+        allowNonExistent: false,
+    });
+    const existingPaths = new Set(listFileNames(codingContext, FileListType.All));
+    // Don't allow the config file to be added
+    existingPaths.add(CONFIG_FILE_PATH);
+    const pathsToAdd = Array.from(requestedPaths).filter((p) => !existingPaths.has(p));
+    const addedFiles = listFileNames(codingContext, FileListType.UserAddedFiles)
+        .concat(pathsToAdd);
+    const updatedFiles = {};
+    const decoder = new TextDecoder("utf-8");
+    for (const path of pathsToAdd) {
+        try {
+            updatedFiles[path] = decoder.decode(await dntShim.Deno.readFile(path));
+        }
+        catch (_e) {
+            throw new CantReadFile(path);
+        }
+    }
+    if (pathsToAdd.length > 0) {
+        const saveFilesRequest = {
+            versionId: codingContext.challengeVersionId,
+            addedFiles,
+            updatedFiles,
+        };
+        const updatedDisplayFiles = Object.keys(updatedFiles);
+        updatedDisplayFiles.sort();
+        console.log(colors.green("Uploading:"));
+        for (const path of updatedDisplayFiles) {
+            console.log(`\t${toNativeStyle(path)}`);
+        }
+        console.log();
+        await api.saveFiles(config.applicantExamId, config.challengeResultId, saveFilesRequest);
+        const newCodingContext = await api.getChallengeCodingContext(config.applicantExamId, config.challengeResultId);
+        printWorkingFileSet(newCodingContext);
+    }
+    else {
+        console.log("No files to add.");
+        console.log();
+        printWorkingFileSet(codingContext);
+    }
+}

package/esm/src/action/clone.d.ts

@@ -0,0 +1,6 @@
+export interface CloneOptions {
+    targetDir?: string;
+    basicAuthUser?: string;
+    basicAuthPassword?: string;
+}
+export declare function clone(url: string, options?: CloneOptions): Promise<void>;

package/esm/src/action/clone.js

@@ -0,0 +1,108 @@
+import * as dntShim from "../../_dnt.shims.js";
+import * as config from "../shared/config.js";
+import { ChallengeDirectoryExists, InvalidChallengeId, LocalExamNotAllowed, OtherError, } from "../shared/errors.js";
+import { downloadChallengeFilesTo, ensureExamInProgress, getChallengeFromExamSession, printTimeLeft, tryStartingChallenge, } from "../shared/mod.js";
+import { TrackClient } from "../track/client.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}`);
+    const cloneData = parseUrl(url);
+    const basicAuth = options?.basicAuthUser
+        ? {
+            username: options?.basicAuthUser,
+            password: options?.basicAuthPassword,
+        }
+        : undefined;
+    const authData = {
+        examToken: cloneData.examToken,
+        orgName: cloneData.orgName,
+    };
+    const api = new TrackClient(cloneData.scheme, cloneData.host, basicAuth, authData);
+    await api.authenticate();
+    const applicantExam = await api.getApplicantExamNoAuth(cloneData.examToken);
+    const webUrl = `${cloneData.scheme}://${cloneData.host}/${cloneData.orgName}/exams/${cloneData.examToken}`;
+    ensureExamInProgress(applicantExam, webUrl);
+    const examSession = await api.getExamSession(applicantExam.id);
+    // Determine challenge directory
+    const challengePosition = examSession.challengesSets
+        .flatMap((set) => set.challenges)
+        .findIndex((challenge) => challenge.id === cloneData.challengeId) +
+        1;
+    const challengeDir = options?.targetDir ||
+        `${cloneData.orgName}-challenge-${challengePosition}`;
+    const configDir = `${challengeDir}/.track`;
+    const configFile = `${configDir}/config.json`;
+    const pathExists = await exists(challengeDir);
+    if (pathExists) {
+        // オリジナルの Track CLI では空ディレクトリなら OK だったが、そのケースで特に便利にならないので、ファイル・ディレクトリが存在したら無条件でエラーに
+        throw new ChallengeDirectoryExists(challengeDir);
+    }
+    const challenge = getChallengeFromExamSession(examSession, cloneData.challengeId);
+    if (!challenge) {
+        throw new InvalidChallengeId(cloneData.challengeId);
+    }
+    if (!challenge.localExamEnabled) {
+        throw new LocalExamNotAllowed(webUrl);
+    }
+    // Find the challenge result if it exists
+    const resultOpt = getResultFromExamSession(examSession, cloneData.challengeId);
+    // Steps:
+    // - Prepare Challenge
+    // - Change language
+    // - Start Challenge
+    // - TimeLeft
+    // - Context
+    // - Presigned
+    // - Download files
+    // TODO - Print warnings about challenge time limit, having
+    //        a stable internet connection, and what to do next
+    //        in the challenge solving process.
+    const result = await tryStartingChallenge(challenge, api, applicantExam, resultOpt);
+    if (!result) {
+        throw new OtherError("Expected to have a challenge result after preparing and starting");
+    }
+    const timeLeft = await api.timeLeft(applicantExam.id, result.id);
+    printTimeLeft(timeLeft);
+    const codingContext = await api.getChallengeCodingContext(applicantExam.id, result.id);
+    await dntShim.Deno.mkdir(challengeDir, { recursive: true });
+    const showFileDiff = false;
+    const includeTarball = true;
+    await downloadChallengeFilesTo(codingContext, challengeDir, api, applicantExam.id, result.id, showFileDiff, includeTarball);
+    const trackConfig = {
+        scheme: cloneData.scheme,
+        host: cloneData.host,
+        orgName: cloneData.orgName,
+        basicAuth: basicAuth,
+        examToken: cloneData.examToken,
+        applicantExamId: applicantExam.id,
+        challengeId: cloneData.challengeId,
+        challengeResultId: result.id,
+        cookies: api.getCookies(),
+        programmingLanguage: result.programmingLanguage,
+    };
+    await config.save(trackConfig, { path: configFile });
+    console.log();
+    console.log(`Challenge downloaded to ${challengeDir}`);
+    console.log(`Run 'cd ${challengeDir} && track status' to begin!`);
+}
+const PATH_PATTERN = new RegExp("([^/]+)/exams/([^/]+)/challenges/(\\d+)");
+function parseUrl(url) {
+    const urlObj = new URL(url);
+    const caps = PATH_PATTERN.exec(url);
+    if (!caps) {
+        throw new OtherError(`Invalid URL: ${url}`);
+    }
+    return {
+        scheme: urlObj.protocol.slice(0, -1),
+        host: urlObj.host + (urlObj.port ? ":" + urlObj.port : ""),
+        orgName: caps[1],
+        examToken: caps[2],
+        challengeId: parseInt(caps[3]),
+    };
+}
+function getResultFromExamSession(examSession, challengeId) {
+    return examSession.results.find((r) => r.challengeId === challengeId);
+}

package/esm/src/action/lang.d.ts

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

package/esm/src/action/lang.js

@@ -0,0 +1,40 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { save as saveConfig } from "../shared/config.js";
+import { CantChooseLanguage, InvalidChallengeId } from "../shared/errors.js";
+import { archiveExistingChallengeFiles, chooseProgrammingLanguage, downloadChallengeFilesTo, getChallengeFromExamSession, getCommonChallengeContext, } from "../shared/mod.js";
+export async function lang() {
+    const trackContext = await getCommonChallengeContext();
+    const { config, api, codingContext, applicantExam, challengeResult, challengePosition, } = trackContext;
+    const examSession = await api.getExamSession(applicantExam.id);
+    const challenge = getChallengeFromExamSession(examSession, codingContext.challengeId) ??
+        (() => {
+            throw new InvalidChallengeId(codingContext.challengeId);
+        })();
+    if (challenge.programmingLanguages.length === 0) {
+        throw new CantChooseLanguage();
+    }
+    const availableLanguages = (await api.getProgrammingLanguages())
+        .filter((pl) => codingContext.programmingLanguages.find((n) => 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? (y/n):");
+    if (!shouldContinue) {
+        return;
+    }
+    const desiredLanguage = await chooseProgrammingLanguage(availableLanguages);
+    if (desiredLanguage.value === codingContext.selectedLanguage) {
+        console.log("You are already using this language");
+        return;
+    }
+    await api.switchChallengeLanguage(config.applicantExamId, config.challengeResultId, desiredLanguage.value);
+    const currentDir = dntShim.Deno.cwd();
+    const selectedLanguage = availableLanguages.find((pl) => pl.value === codingContext.selectedLanguage);
+    await archiveExistingChallengeFiles(config.orgName, challengePosition, { selectedLanguage, challengeDir: currentDir });
+    const newCodingContext = await api.getChallengeCodingContext(config.applicantExamId, config.challengeResultId);
+    const showFileDiff = false;
+    const includeTarball = true;
+    await downloadChallengeFilesTo(newCodingContext, currentDir, api, applicantExam.id, challengeResult.id, showFileDiff, includeTarball);
+    const updatedConfig = Object.assign({}, config, {
+        programmingLanguage: desiredLanguage.value,
+    });
+    await saveConfig(updatedConfig);
+}

package/esm/src/action/pull.d.ts

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