@halooj/common 0.0.10

package/cases.ts

@@ -0,0 +1,50 @@
+import { findFileSync, parseMemoryMB, parseTimeMS } from '@halooj/utils';
+import { CompilableSource, ProblemConfigFile } from './types';
+
+// eslint-disable-next-line ts/no-unused-vars
+export async function readYamlCases(cfg: ProblemConfigFile = {}, checkFile = (s: CompilableSource, errMsg: string) => s) {
+    const config: any = {
+        checker_type: cfg.checker_type || 'default',
+        judge_extra_files: [],
+        user_extra_files: [],
+    };
+    const checkFileWithLang = (s: CompilableSource, errMsg: string) => {
+        if (typeof s === 'string') return { lang: 'auto', file: checkFile(s, errMsg) };
+        return { lang: s.lang, file: checkFile(s.file, errMsg) };
+    };
+    if (cfg.type === 'objective') {
+        if (cfg.checker || cfg.interactor || cfg.validator) {
+            throw new Error('You cannot use checker, interactor or validator for objective questions');
+        }
+    } else {
+        if (cfg.checker) {
+            const [name, lang] = typeof cfg.checker === 'string' ? [cfg.checker, 'auto'] : [cfg.checker.file, cfg.checker.lang || 'auto'];
+            if (!name.includes('.')) {
+                config.checker = {
+                    lang,
+                    file: findFileSync(`@halooj/hydrojudge/vendor/testlib/checkers/${name}.cpp`, false),
+                };
+            }
+            config.checker ||= checkFileWithLang(name, 'Cannot find checker {0}.');
+        }
+        if (cfg.interactor) config.interactor = checkFileWithLang(cfg.interactor, 'Cannot find interactor {0}.');
+        if (cfg.manager) config.manager = checkFileWithLang(cfg.manager, 'Cannot find Manager {0}.');
+        if (cfg.validator) config.validator = checkFileWithLang(cfg.validator, 'Cannot find validator {0}.');
+        for (const n of ['judge', 'user']) {
+            const conf = cfg[`${n}_extra_files`];
+            if (!conf) continue;
+            if (conf instanceof Array) {
+                config[`${n}_extra_files`] = conf.map((file) => checkFile(file, `Cannot find ${n} extra file {0}.`));
+            } else throw new Error(`Invalid ${n}_extra_files config.`);
+        }
+    }
+    if (cfg.cases?.length) {
+        config.subtasks = [{
+            cases: cfg.cases,
+            type: 'sum',
+        }];
+    }
+    if (cfg.time) config.time = parseTimeMS(cfg.time);
+    if (cfg.memory) config.memory = parseMemoryMB(cfg.memory);
+    return Object.assign(cfg, config);
+}

package/index.ts

@@ -0,0 +1,5 @@
+export * from './lang';
+export * from './permission';
+export * from './status';
+export * from './subtask';
+export * from './types';

package/lang.ts

@@ -0,0 +1,60 @@
+import yaml from 'js-yaml';
+
+export interface LangConfig {
+    disabled?: boolean;
+    compile?: string;
+    execute: string;
+    code_file: string;
+    highlight: string;
+    monaco: string;
+    time_limit_rate: number;
+    memory_limit_rate: number;
+    address_space_limit?: boolean;
+    process_limit?: number;
+    display: string;
+    target?: string;
+    key: string;
+    hidden: boolean;
+    isBinary?: boolean;
+    analysis?: string;
+    remote: boolean;
+    validAs?: Record<string, string>;
+    /** @deprecated */
+    pretest?: string | false;
+    comment?: string | [string, string];
+    compile_time_limit?: number;
+    compile_memory_limit?: number;
+    version?: string;
+}
+
+export function parseLang(config: string): Record<string, LangConfig> {
+    const file = yaml.load(config) as Record<string, LangConfig>;
+    if (typeof file === 'undefined' || typeof file === 'string' || typeof file === 'number') throw new Error();
+    for (const key of Object.keys(file)) if (key.startsWith('_')) delete file[key];
+    for (const key in file) {
+        const entry = file[key];
+        if (key.includes('.')) {
+            const base = key.split('.')[0];
+            const baseCfg = file[base];
+            for (const bkey in baseCfg || {}) {
+                if (!(bkey in entry)) entry[bkey] = baseCfg[bkey];
+            }
+        }
+    }
+    for (const key in file) {
+        const entry = file[key];
+        entry.highlight ||= key;
+        entry.monaco ||= entry.highlight;
+        entry.time_limit_rate ||= 1;
+        entry.memory_limit_rate ||= 1;
+        entry.code_file ||= `foo.${key}`;
+        entry.execute ||= '/w/foo';
+        entry.key = key;
+        entry.remote = !!entry.remote;
+        entry.hidden ||= false;
+        entry.disabled ||= false;
+        entry.isBinary ||= false;
+        entry.validAs ||= {};
+    }
+    return file;
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "@halooj/common",
+    "main": "./index.ts",
+    "version": "0.0.10",
+    "repository": "https://github.com/hydro-dev/Hydro",
+    "sideEffects": false,
+    "dependencies": {
+        "@halooj/utils": "^1.5.6"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/permission.ts

@@ -0,0 +1,210 @@
+export const PERM = {
+    PERM_NONE: 0n,
+
+    // Domain Settings
+    PERM_VIEW: 1n << 0n,
+    PERM_EDIT_DOMAIN: 1n << 1n,
+    /** @deprecated use PERM_VIEW_USER_PRIVATE_INFO instead */
+    PERM_VIEW_DISPLAYNAME: 1n << 67n,
+    PERM_VIEW_USER_PRIVATE_INFO: 1n << 67n,
+    PERM_MOD_BADGE: 1n << 2n,
+
+    // Problem
+    PERM_CREATE_PROBLEM: 1n << 4n,
+    PERM_EDIT_PROBLEM: 1n << 5n,
+    PERM_EDIT_PROBLEM_SELF: 1n << 6n,
+    PERM_VIEW_PROBLEM: 1n << 7n,
+    PERM_VIEW_PROBLEM_HIDDEN: 1n << 8n,
+    PERM_SUBMIT_PROBLEM: 1n << 9n,
+    PERM_READ_PROBLEM_DATA: 1n << 10n,
+
+    // Record
+    PERM_VIEW_RECORD: 1n << 70n,
+    PERM_READ_RECORD_CODE: 1n << 12n,
+    PERM_READ_RECORD_CODE_ACCEPT: 1n << 66n,
+    PERM_REJUDGE_PROBLEM: 1n << 13n,
+    PERM_REJUDGE: 1n << 14n,
+
+    // Problem Solution
+    PERM_VIEW_PROBLEM_SOLUTION: 1n << 15n,
+    PERM_VIEW_PROBLEM_SOLUTION_ACCEPT: 1n << 65n,
+    PERM_CREATE_PROBLEM_SOLUTION: 1n << 16n,
+    PERM_VOTE_PROBLEM_SOLUTION: 1n << 17n,
+    PERM_EDIT_PROBLEM_SOLUTION: 1n << 18n,
+    PERM_EDIT_PROBLEM_SOLUTION_SELF: 1n << 19n,
+    PERM_DELETE_PROBLEM_SOLUTION: 1n << 20n,
+    PERM_DELETE_PROBLEM_SOLUTION_SELF: 1n << 21n,
+    PERM_REPLY_PROBLEM_SOLUTION: 1n << 22n,
+    PERM_EDIT_PROBLEM_SOLUTION_REPLY_SELF: 1n << 24n,
+    PERM_DELETE_PROBLEM_SOLUTION_REPLY: 1n << 25n,
+    PERM_DELETE_PROBLEM_SOLUTION_REPLY_SELF: 1n << 26n,
+
+    // Discussion
+    PERM_VIEW_DISCUSSION: 1n << 27n,
+    PERM_CREATE_DISCUSSION: 1n << 28n,
+    PERM_HIGHLIGHT_DISCUSSION: 1n << 29n,
+    PERM_PIN_DISCUSSION: 1n << 61n,
+    PERM_EDIT_DISCUSSION: 1n << 30n,
+    PERM_EDIT_DISCUSSION_SELF: 1n << 31n,
+    PERM_DELETE_DISCUSSION: 1n << 32n,
+    PERM_DELETE_DISCUSSION_SELF: 1n << 33n,
+    PERM_REPLY_DISCUSSION: 1n << 34n,
+    PERM_ADD_REACTION: 1n << 62n,
+    PERM_EDIT_DISCUSSION_REPLY_SELF: 1n << 36n,
+    PERM_DELETE_DISCUSSION_REPLY: 1n << 38n,
+    PERM_DELETE_DISCUSSION_REPLY_SELF: 1n << 39n,
+    PERM_DELETE_DISCUSSION_REPLY_SELF_DISCUSSION: 1n << 40n,
+    PERM_LOCK_DISCUSSION: 1n << 64n,
+
+    // Contest
+    PERM_VIEW_CONTEST: 1n << 41n,
+    PERM_VIEW_CONTEST_SCOREBOARD: 1n << 42n,
+    PERM_VIEW_CONTEST_HIDDEN_SCOREBOARD: 1n << 43n,
+    PERM_CREATE_CONTEST: 1n << 44n,
+    PERM_ATTEND_CONTEST: 1n << 45n,
+    PERM_EDIT_CONTEST: 1n << 50n,
+    PERM_EDIT_CONTEST_SELF: 1n << 51n,
+    PERM_VIEW_HIDDEN_CONTEST: 1n << 68n,
+
+    // Homework
+    PERM_VIEW_HOMEWORK: 1n << 52n,
+    PERM_VIEW_HOMEWORK_SCOREBOARD: 1n << 53n,
+    PERM_VIEW_HOMEWORK_HIDDEN_SCOREBOARD: 1n << 54n,
+    PERM_CREATE_HOMEWORK: 1n << 55n,
+    PERM_ATTEND_HOMEWORK: 1n << 56n,
+    PERM_EDIT_HOMEWORK: 1n << 57n,
+    PERM_EDIT_HOMEWORK_SELF: 1n << 58n,
+    PERM_VIEW_HIDDEN_HOMEWORK: 1n << 69n,
+
+    // Training
+    PERM_VIEW_TRAINING: 1n << 46n,
+    PERM_CREATE_TRAINING: 1n << 47n,
+    PERM_EDIT_TRAINING: 1n << 48n,
+    PERM_PIN_TRAINING: 1n << 63n,
+    PERM_EDIT_TRAINING_SELF: 1n << 49n,
+
+    // Ranking
+    PERM_VIEW_RANKING: 1n << 59n,
+
+    // HaloOJ Advanced Domain
+    PERM_EDIT_DOMAIN_ADVANCED: 1n << 71n,
+    PERM_IMPORT_USER: 1n << 72n,
+    PERM_VIEW_USER_LIST: 1n << 73n,
+    PERM_VIEW_COURSE: 1n << 74n,
+    PERM_EDIT_COURSE: 1n << 75n,
+    PERM_VIEW_EXAM: 1n << 76n,
+    PERM_EDIT_EXAM: 1n << 77n,
+    PERM_USE_AI: 1n << 78n,
+    PERM_USE_BLOCKLY: 1n << 79n,
+    PERM_DOWNLOAD_FIRST_WA: 1n << 80n,
+    PERM_CONTEST_PDF: 1n << 81n,
+    PERM_CONTEST_BULK_SUBMIT: 1n << 82n,
+
+    // Placeholder
+    PERM_ALL: -1n,
+    PERM_BASIC: 0n,
+    PERM_DEFAULT: 0n,
+    PERM_ADMIN: -1n,
+
+    PERM_NEVER: 1n << 60n,
+};
+
+PERM.PERM_BASIC = PERM.PERM_VIEW
+    | PERM.PERM_VIEW_PROBLEM
+    | PERM.PERM_VIEW_PROBLEM_SOLUTION
+    | PERM.PERM_VIEW_PROBLEM_SOLUTION_ACCEPT
+    | PERM.PERM_VIEW_DISCUSSION
+    | PERM.PERM_VIEW_CONTEST
+    | PERM.PERM_VIEW_CONTEST_SCOREBOARD
+    | PERM.PERM_VIEW_HOMEWORK
+    | PERM.PERM_VIEW_HOMEWORK_SCOREBOARD
+    | PERM.PERM_VIEW_TRAINING
+    | PERM.PERM_VIEW_RANKING
+    | PERM.PERM_VIEW_COURSE
+    | PERM.PERM_USE_BLOCKLY;
+
+PERM.PERM_DEFAULT = PERM.PERM_VIEW
+    | PERM.PERM_VIEW_USER_PRIVATE_INFO
+    | PERM.PERM_VIEW_PROBLEM
+    | PERM.PERM_EDIT_PROBLEM_SELF
+    | PERM.PERM_SUBMIT_PROBLEM
+    | PERM.PERM_VIEW_PROBLEM_SOLUTION
+    | PERM.PERM_VIEW_PROBLEM_SOLUTION_ACCEPT
+    | PERM.PERM_CREATE_PROBLEM_SOLUTION
+    | PERM.PERM_VOTE_PROBLEM_SOLUTION
+    | PERM.PERM_EDIT_PROBLEM_SOLUTION_SELF
+    | PERM.PERM_DELETE_PROBLEM_SOLUTION_SELF
+    | PERM.PERM_REPLY_PROBLEM_SOLUTION
+    | PERM.PERM_EDIT_PROBLEM_SOLUTION_REPLY_SELF
+    | PERM.PERM_DELETE_PROBLEM_SOLUTION_REPLY_SELF
+    | PERM.PERM_VIEW_DISCUSSION
+    | PERM.PERM_CREATE_DISCUSSION
+    | PERM.PERM_EDIT_DISCUSSION_SELF
+    | PERM.PERM_REPLY_DISCUSSION
+    | PERM.PERM_ADD_REACTION
+    | PERM.PERM_EDIT_DISCUSSION_REPLY_SELF
+    | PERM.PERM_DELETE_DISCUSSION_REPLY_SELF
+    | PERM.PERM_DELETE_DISCUSSION_REPLY_SELF_DISCUSSION
+    | PERM.PERM_VIEW_CONTEST
+    | PERM.PERM_VIEW_CONTEST_SCOREBOARD
+    | PERM.PERM_ATTEND_CONTEST
+    | PERM.PERM_EDIT_CONTEST_SELF
+    | PERM.PERM_VIEW_HOMEWORK
+    | PERM.PERM_VIEW_HOMEWORK_SCOREBOARD
+    | PERM.PERM_ATTEND_HOMEWORK
+    | PERM.PERM_EDIT_HOMEWORK_SELF
+    | PERM.PERM_VIEW_TRAINING
+    | PERM.PERM_CREATE_TRAINING
+    | PERM.PERM_EDIT_TRAINING_SELF
+    | PERM.PERM_SUBMIT_PROBLEM
+    | PERM.PERM_CREATE_PROBLEM_SOLUTION
+    | PERM.PERM_VOTE_PROBLEM_SOLUTION
+    | PERM.PERM_REPLY_PROBLEM_SOLUTION
+    | PERM.PERM_CREATE_DISCUSSION
+    | PERM.PERM_REPLY_DISCUSSION
+    | PERM.PERM_ATTEND_CONTEST
+    | PERM.PERM_CREATE_TRAINING
+    | PERM.PERM_ATTEND_HOMEWORK
+    | PERM.PERM_VIEW_RANKING
+    | PERM.PERM_VIEW_RECORD
+    | PERM.PERM_VIEW_COURSE
+    | PERM.PERM_VIEW_EXAM
+    | PERM.PERM_USE_AI
+    | PERM.PERM_USE_BLOCKLY
+    | PERM.PERM_DOWNLOAD_FIRST_WA
+    | PERM.PERM_CONTEST_PDF;
+
+PERM.PERM_ADMIN = PERM.PERM_ALL;
+
+export const PRIV = {
+    PRIV_NONE: 0,
+    PRIV_MOD_BADGE: 1 << 25,
+    PRIV_EDIT_SYSTEM: 1 << 0, // renamed from PRIV_SET_PRIV
+    PRIV_SET_PERM: 1 << 1,
+    PRIV_USER_PROFILE: 1 << 2,
+    PRIV_REGISTER_USER: 1 << 3,
+    PRIV_READ_PROBLEM_DATA: 1 << 4,
+    PRIV_READ_RECORD_CODE: 1 << 7,
+    PRIV_VIEW_HIDDEN_RECORD: 1 << 8,
+    PRIV_JUDGE: 1 << 9, // (renamed)
+    PRIV_CREATE_DOMAIN: 1 << 10,
+    PRIV_VIEW_ALL_DOMAIN: 1 << 11,
+    PRIV_MANAGE_ALL_DOMAIN: 1 << 12,
+    PRIV_REJUDGE: 1 << 13,
+    PRIV_VIEW_USER_SECRET: 1 << 14,
+    PRIV_VIEW_JUDGE_STATISTICS: 1 << 15,
+    PRIV_UNLIMITED_ACCESS: 1 << 22,
+    PRIV_VIEW_SYSTEM_NOTIFICATION: 1 << 23,
+    PRIV_SEND_MESSAGE: 1 << 24,
+    PRIV_CREATE_FILE: 1 << 16,
+    PRIV_UNLIMITED_QUOTA: 1 << 17,
+    PRIV_DELETE_FILE: 1 << 18,
+
+    PRIV_ALL: -1,
+    PRIV_DEFAULT: 0,
+    PRIV_NEVER: 1 << 20,
+};
+
+PRIV.PRIV_DEFAULT = PRIV.PRIV_USER_PROFILE
+    + PRIV.PRIV_CREATE_FILE
+    + PRIV.PRIV_SEND_MESSAGE;

package/status.ts

@@ -0,0 +1,122 @@
+export enum STATUS {
+    STATUS_WAITING = 0,
+    STATUS_ACCEPTED = 1,
+    STATUS_WRONG_ANSWER = 2,
+    STATUS_TIME_LIMIT_EXCEEDED = 3,
+    STATUS_MEMORY_LIMIT_EXCEEDED = 4,
+    STATUS_OUTPUT_LIMIT_EXCEEDED = 5,
+    STATUS_RUNTIME_ERROR = 6,
+    STATUS_COMPILE_ERROR = 7,
+    STATUS_SYSTEM_ERROR = 8,
+    STATUS_CANCELED = 9,
+    STATUS_ETC = 10,
+    STATUS_HACKED = 11,
+    STATUS_JUDGING = 20,
+    STATUS_COMPILING = 21,
+    STATUS_FETCHED = 22,
+    STATUS_IGNORED = 30,
+    STATUS_FORMAT_ERROR = 31,
+    STATUS_HACK_SUCCESSFUL = 32,
+    STATUS_HACK_UNSUCCESSFUL = 33,
+}
+
+export const STATUS_TEXTS: Record<STATUS, string> = {
+    [STATUS.STATUS_WAITING]: 'Waiting',
+    [STATUS.STATUS_ACCEPTED]: 'Accepted',
+    [STATUS.STATUS_WRONG_ANSWER]: 'Wrong Answer',
+    [STATUS.STATUS_TIME_LIMIT_EXCEEDED]: 'Time Exceeded',
+    [STATUS.STATUS_MEMORY_LIMIT_EXCEEDED]: 'Memory Exceeded',
+    [STATUS.STATUS_OUTPUT_LIMIT_EXCEEDED]: 'Output Exceeded',
+    [STATUS.STATUS_RUNTIME_ERROR]: 'Runtime Error',
+    [STATUS.STATUS_COMPILE_ERROR]: 'Compile Error',
+    [STATUS.STATUS_SYSTEM_ERROR]: 'System Error',
+    [STATUS.STATUS_CANCELED]: 'Cancelled',
+    [STATUS.STATUS_ETC]: 'Unknown Error',
+    [STATUS.STATUS_HACKED]: 'Hacked',
+    [STATUS.STATUS_JUDGING]: 'Running',
+    [STATUS.STATUS_COMPILING]: 'Compiling',
+    [STATUS.STATUS_FETCHED]: 'Fetched',
+    [STATUS.STATUS_IGNORED]: 'Ignored',
+    [STATUS.STATUS_FORMAT_ERROR]: 'Format Error',
+    [STATUS.STATUS_HACK_SUCCESSFUL]: 'Hack Successful',
+    [STATUS.STATUS_HACK_UNSUCCESSFUL]: 'Hack Unsuccessful',
+};
+
+export const STATUS_SHORT_TEXTS: Partial<Record<STATUS, string>> = {
+    [STATUS.STATUS_ACCEPTED]: 'AC',
+    [STATUS.STATUS_WRONG_ANSWER]: 'WA',
+    [STATUS.STATUS_TIME_LIMIT_EXCEEDED]: 'TLE',
+    [STATUS.STATUS_MEMORY_LIMIT_EXCEEDED]: 'MLE',
+    [STATUS.STATUS_OUTPUT_LIMIT_EXCEEDED]: 'OLE',
+    [STATUS.STATUS_RUNTIME_ERROR]: 'RE',
+    [STATUS.STATUS_COMPILE_ERROR]: 'CE',
+    [STATUS.STATUS_SYSTEM_ERROR]: 'SE',
+    [STATUS.STATUS_CANCELED]: 'IGN',
+    [STATUS.STATUS_HACKED]: 'HK',
+    [STATUS.STATUS_IGNORED]: 'IGN',
+    [STATUS.STATUS_FORMAT_ERROR]: 'FE',
+};
+
+export const STATUS_CODES: Record<STATUS, string> = {
+    [STATUS.STATUS_WAITING]: 'pending',
+    [STATUS.STATUS_ACCEPTED]: 'pass',
+    [STATUS.STATUS_WRONG_ANSWER]: 'fail',
+    [STATUS.STATUS_TIME_LIMIT_EXCEEDED]: 'fail',
+    [STATUS.STATUS_MEMORY_LIMIT_EXCEEDED]: 'fail',
+    [STATUS.STATUS_OUTPUT_LIMIT_EXCEEDED]: 'fail',
+    [STATUS.STATUS_RUNTIME_ERROR]: 'fail',
+    [STATUS.STATUS_COMPILE_ERROR]: 'fail',
+    [STATUS.STATUS_SYSTEM_ERROR]: 'fail',
+    [STATUS.STATUS_CANCELED]: 'ignored',
+    [STATUS.STATUS_ETC]: 'fail',
+    [STATUS.STATUS_HACKED]: 'fail',
+    [STATUS.STATUS_JUDGING]: 'progress',
+    [STATUS.STATUS_COMPILING]: 'progress',
+    [STATUS.STATUS_FETCHED]: 'progress',
+    [STATUS.STATUS_IGNORED]: 'ignored',
+    [STATUS.STATUS_FORMAT_ERROR]: 'ignored',
+    [STATUS.STATUS_HACK_SUCCESSFUL]: 'pass',
+    [STATUS.STATUS_HACK_UNSUCCESSFUL]: 'fail',
+};
+
+export const NORMAL_STATUS: STATUS[] = [
+    STATUS.STATUS_ACCEPTED,
+    STATUS.STATUS_WRONG_ANSWER,
+    STATUS.STATUS_TIME_LIMIT_EXCEEDED,
+    STATUS.STATUS_MEMORY_LIMIT_EXCEEDED,
+    STATUS.STATUS_OUTPUT_LIMIT_EXCEEDED,
+    STATUS.STATUS_RUNTIME_ERROR,
+    STATUS.STATUS_COMPILE_ERROR,
+];
+
+export function getScoreColor(score: number | string): string {
+    if (score === null || score === undefined || !Number.isFinite(+score)) return '#000000';
+    return [
+        '#ff4f4f',
+        '#ff694f',
+        '#f8603a',
+        '#fc8354',
+        '#fa9231',
+        '#f7bb3b',
+        '#ecdb44',
+        '#e2ec52',
+        '#b0d628',
+        '#93b127',
+        '#25ad40',
+    ][Math.floor((Number(score) || 0) / 10)];
+}
+
+export const USER_GENDER_MALE = 0;
+export const USER_GENDER_FEMALE = 1;
+export const USER_GENDER_OTHER = 2;
+export const USER_GENDERS = [USER_GENDER_MALE, USER_GENDER_FEMALE, USER_GENDER_OTHER];
+export const USER_GENDER_RANGE = {
+    [USER_GENDER_MALE]: 'Boy ♂',
+    [USER_GENDER_FEMALE]: 'Girl ♀',
+    [USER_GENDER_OTHER]: 'Other',
+};
+export const USER_GENDER_ICONS = {
+    [USER_GENDER_MALE]: '♂',
+    [USER_GENDER_FEMALE]: '♀',
+    [USER_GENDER_OTHER]: '?',
+};

package/subtask.ts

@@ -0,0 +1,180 @@
+import { parseMemoryMB, parseTimeMS, sortFiles } from '@halooj/utils/lib/common';
+
+export function convertIniConfig(ini: string) {
+    const f = ini.split('\n');
+    const count = Number.parseInt(f[0], 10);
+    const res = { subtasks: [] };
+    for (let i = 1; i <= count; i++) {
+        if (!f[i]?.trim()) throw new Error('Testdata count incorrect.');
+        const [input, output, time, score, memory] = f[i].split('|');
+        const cur = {
+            cases: [{ input, output }],
+            score: Number.parseInt(score, 10),
+            time: `${time}s`,
+            memory: '256m',
+        };
+        if (!Number.isNaN(Number.parseInt(memory, 10))) cur.memory = `${Math.floor(Number.parseInt(memory, 10) / 1024)}m`;
+        res.subtasks.push(cur);
+    }
+    return res;
+}
+
+interface MatchRule {
+    regex: RegExp;
+    output: (a: RegExpExecArray) => string[];
+    id: (a: RegExpExecArray) => number;
+    subtask: (a: RegExpExecArray) => number;
+    preferredScorerType: (a: RegExpExecArray) => 'min' | 'max' | 'sum';
+}
+
+const SubtaskMatcher: MatchRule[] = [
+    {
+        // eslint-disable-next-line regexp/no-super-linear-backtracking
+        regex: /^(([\w.-]*?)(?:(\d*)[-_])?(\d+))\.(in|IN|txt|TXT|in\.txt|IN\.TXT)$/,
+        output: (a) => ['out', 'ans']
+            .flatMap((i) => [i, i.toUpperCase(), `${i}.txt`, `${i.toUpperCase()}.TXT`])
+            .flatMap((i) => [`${a[1]}.${i}`, `${a[1]}.${i}`.replace(/input/g, 'output').replace(/INPUT/g, 'OUTPUT')])
+            .concat(a[1].includes('input') ? `${a[1]}.txt`.replace(/input/g, 'output') : null),
+        id: (a) => +a[4],
+        subtask: (a) => +(a[3] || 1),
+        preferredScorerType: (a) => (a[3] ? 'min' : 'sum'),
+    },
+    {
+        regex: /^(\D*)\.(in|IN)(\d+)$/,
+        output: (a) => [
+            `${a[1]}.${a[2] === 'in' ? 'ou' : 'OU'}${a[3]}`,
+            `${a[1]}.${a[2] === 'in' ? 'out' : 'OUT'}${a[3]}`,
+        ].flatMap((i) => [i, i.replace(/input/g, 'output').replace(/INPUT/g, 'OUTPUT')]),
+        id: (a) => +a[2],
+        subtask: () => 1,
+        preferredScorerType: () => 'sum',
+    },
+    {
+        regex: /^(\D*)([0-9]+)([-_])([0-9]+)\.(in|IN)$/,
+        output: (a) => ['out', 'ans', 'OUT', 'ANS'].flatMap((i) => `${a[1]}${a[2]}${a[3]}${a[4]}.${i}`),
+        id: (a) => +a[4],
+        subtask: (a) => +a[2],
+        preferredScorerType: () => 'min',
+    },
+    {
+        regex: /^(([0-9]+)[-_].*)\.(in|IN)$/,
+        output: (a) => ['out', 'ans', 'OUT', 'ANS'].flatMap((i) => `${a[1]}.${i}`),
+        id: (a) => +a[2],
+        subtask: () => 1,
+        preferredScorerType: () => 'sum',
+    },
+];
+
+function* getScore(totalScore: number, count: number) {
+    const base = Math.floor(totalScore / count);
+    const extra = count - (totalScore % count);
+    for (let i = 0; i < count; i++) {
+        if (i >= extra) yield base + 1;
+        else yield base;
+    }
+}
+
+interface ParsedCase {
+    id?: number;
+    time?: number | string;
+    memory?: number | string;
+    score?: number;
+    input?: string;
+    output?: string;
+}
+interface ParsedSubtask {
+    cases: ParsedCase[];
+    type: 'min' | 'max' | 'sum';
+    time?: number | string;
+    memory?: number | string;
+    score?: number;
+    id?: number;
+    if?: number[];
+}
+
+export function readSubtasksFromFiles(files: string[], config) {
+    const subtask: Record<number, ParsedSubtask> = {};
+    for (const s of config.subtasks || []) if (s.id && Number.isSafeInteger(s.id)) subtask[s.id] = s;
+    for (const file of files) {
+        let match = false;
+        for (const rule of SubtaskMatcher) {
+            const data = rule.regex.exec(file);
+            if (!data) continue;
+            const sid = rule.subtask(data);
+            const c = { input: file, output: '', id: rule.id(data) };
+            const type = rule.preferredScorerType(data);
+            const outputs = (config.noOutputFile ? ['/dev/null'] : rule.output(data)).filter((i) => i);
+            for (const output of outputs) {
+                if (output === file) continue;
+                if (output === '/dev/null' || files.includes(output)) {
+                    match = true;
+                    c.output = output;
+                    if (!subtask[sid]) {
+                        subtask[sid] = {
+                            time: config.time,
+                            memory: config.memory,
+                            type,
+                            cases: [c],
+                            id: sid,
+                        };
+                    } else if (!subtask[sid].cases) subtask[sid].cases = [c];
+                    else if (!subtask[sid].cases.find((i) => i.input === c.input && i.output === c.output)) {
+                        subtask[sid].cases.push(c);
+                    }
+                    break;
+                }
+            }
+            if (match) break;
+        }
+    }
+    for (const id in subtask) subtask[id].cases = sortFiles(subtask[id].cases, 'input');
+    return Object.values(subtask);
+}
+
+export interface NormalizedCase extends Required<ParsedCase> {
+    time: number;
+    memory: number;
+}
+export interface NormalizedSubtask extends Required<ParsedSubtask> {
+    cases: NormalizedCase[];
+    time: number;
+    memory: number;
+}
+
+export function normalizeSubtasks(
+    subtasks: ParsedSubtask[], checkFile: (name: string, errMsg: string) => string,
+    time: number | string = '1000ms', memory: number | string = '256m', ignoreParseError = false,
+    timeRate = 1, memoryRate = 1,
+): NormalizedSubtask[] {
+    subtasks.sort((a, b) => (a.id - b.id));
+    const subtaskScore = getScore(
+        Math.max(100 - Math.sum(subtasks.map((i) => i.score || 0)), 0),
+        subtasks.filter((i) => !i.score).length,
+    );
+    return subtasks.map((s, id) => {
+        s.cases.sort((a, b) => (a.id - b.id));
+        const score = s.score || subtaskScore.next().value as number;
+        const caseScore = getScore(
+            Math.max(score - Math.sum(s.cases.map((i) => i.score || 0)), 0),
+            s.cases.filter((i) => !i.score).length,
+        );
+        return {
+            id: id + 1,
+            type: 'min',
+            if: [],
+            ...s,
+            score,
+            time: parseTimeMS(s.time || time, !ignoreParseError) * timeRate,
+            memory: parseMemoryMB(s.memory || memory, !ignoreParseError) * memoryRate,
+            cases: s.cases.map((c, index) => ({
+                id: index + 1,
+                ...c,
+                score: c.score || (s.type === 'sum' ? caseScore.next().value as number : score),
+                time: parseTimeMS(c.time || s.time || time, !ignoreParseError) * timeRate,
+                memory: parseMemoryMB(c.memory || s.memory || memory, !ignoreParseError) * memoryRate,
+                input: c.input ? checkFile(c.input, 'Cannot find input file {0}.') : '/dev/null',
+                output: c.output ? checkFile(c.output, 'Cannot find output file {0}.') : '/dev/null',
+            })) as NormalizedCase[],
+        };
+    });
+}

package/tests/subtask.spec.ts

@@ -0,0 +1,62 @@
+import { expect } from 'chai';
+import { describe, it } from 'node:test';
+import { readSubtasksFromFiles } from '../subtask';
+
+interface Info {
+    subtask: number;
+    id: number;
+}
+
+function shouldFindTestcase(files: string[], info?: Info) {
+    const subtasks = readSubtasksFromFiles(files, {});
+    if (files.includes('a2_1.in')) console.log(subtasks);
+    expect(subtasks).to.be.lengthOf(1);
+    if (info?.subtask) expect(subtasks[0].id).to.equal(info.subtask);
+    const cases = subtasks.map((i) => i.cases).flat();
+    expect(cases).to.be.lengthOf(1);
+    if (info?.id) expect(cases[0].id).to.deep.equal(info.id);
+}
+
+describe('single case', () => {
+    it('1.in/1.out', () => {
+        shouldFindTestcase(['1.in', '1.out']);
+    });
+    it('1.in/2.ans', () => {
+        shouldFindTestcase(['1.in', '1.ans']);
+    });
+    it('file1.in/file1.out', () => {
+        shouldFindTestcase(['file1.in', 'file1.out']);
+    });
+    it('file.in1/file.ou1', () => {
+        shouldFindTestcase(['file.in1', 'file.ou1']);
+    });
+    it('input1.txt/output1.txt', () => {
+        shouldFindTestcase(['input1.txt', 'output1.txt']);
+    });
+    it('data.1.in/data.1.out', () => {
+        shouldFindTestcase(['data.1.in', 'data.1.out']);
+    });
+});
+describe('subtask', () => {
+    it('1_1.in/1_1.out', () => {
+        shouldFindTestcase(['1_1.in', '1_1.out'], { subtask: 1, id: 1 });
+    });
+    it('a1_1.in/a1_1.out', () => {
+        shouldFindTestcase(['a1_1.in', 'a1_1.out'], { subtask: 1, id: 1 });
+    });
+    it('a01_01.in/a01_01.out', () => {
+        shouldFindTestcase(['a01_01.in', 'a01_01.out'], { subtask: 1, id: 1 });
+    });
+    it('1-1.in/1-1.out', () => {
+        shouldFindTestcase(['1-1.in', '1-1.out'], { subtask: 1, id: 1 });
+    });
+    it('a1-1.in/a1-1.out', () => {
+        shouldFindTestcase(['a1-1.in', 'a1-1.out'], { subtask: 1, id: 1 });
+    });
+    it('subtask_1_1.in/subtask_1_1.out', () => {
+        shouldFindTestcase(['subtask_1_1.in', 'subtask_1_1.out'], { subtask: 1, id: 1 });
+    });
+    it('01sample-01.in/01sample-01.out', () => {
+        shouldFindTestcase(['01sample-01.in', '01sample-01.out'], { subtask: 1, id: 1 });
+    });
+});

package/tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"target":"es2022","lib":["esnext"],"module":"preserve","esModuleInterop":true,"moduleResolution":"bundler","jsx":"react-jsx","sourceMap":false,"composite":true,"strict":false,"strictBindCallApply":true,"resolveJsonModule":true,"experimentalDecorators":true,"incremental":true,"outDir":"/Users/mac/Desktop/HaloTeam/HaloOJ/未命名/.cache/ts-out/packages/common","rootDir":".","paths":{"vj/*":["../../packages/ui-default/*"]}},"include":["**/*.ts","**/*.tsx"],"exclude":["**/public","**/frontend","**/node_modules","**/bin","**/dist","**/__mocks__"]}

package/types.ts

@@ -0,0 +1,172 @@
+export type CompilableSource = string | {
+    file: string;
+    lang: string;
+};
+
+export enum ProblemType {
+    Default = 'default',
+    SubmitAnswer = 'submit_answer',
+    Interactive = 'interactive',
+    Communication = 'communication',
+    Objective = 'objective',
+    Remote = 'remote_judge',
+}
+
+export interface TestCaseConfig {
+    input: string;
+    output: string;
+    time?: string;
+    memory?: string;
+    score?: number;
+}
+
+export enum SubtaskType {
+    min = 'min',
+    max = 'max',
+    sum = 'sum',
+}
+
+export interface SubtaskConfig {
+    time?: string;
+    memory?: string;
+    score?: number;
+    if?: number[];
+    id?: number;
+    type?: SubtaskType;
+    cases?: TestCaseConfig[];
+}
+
+export type DetailType = 'full' | 'case' | 'none';
+
+export interface ProblemConfigFile {
+    type?: ProblemType;
+    subType?: string;
+    target?: string;
+    score?: number;
+    time?: string;
+    memory?: string;
+    filename?: string;
+    checker_type?: string;
+    num_processes?: number;
+    user_extra_files?: string[];
+    judge_extra_files?: string[];
+    detail?: DetailType | boolean;
+    answers?: Record<string, [string | string[], number]>;
+    redirect?: string;
+    cases?: TestCaseConfig[];
+    subtasks?: SubtaskConfig[];
+    langs?: string[];
+    multi_pass?: number;
+    checker?: CompilableSource;
+    interactor?: CompilableSource;
+    manager?: CompilableSource;
+    validator?: CompilableSource;
+    time_limit_rate?: Record<string, number>;
+    memory_limit_rate?: Record<string, number>;
+}
+
+export interface FileInfo {
+    /** storage path */
+    _id: string;
+    /** filename */
+    name: string;
+    /** file size (in bytes) */
+    size: number;
+    etag: string;
+    lastModified: Date;
+}
+
+export interface JudgeMeta {
+    problemOwner: number;
+    hackRejudge?: string;
+    rejudge?: boolean | 'controlled';
+    // FIXME stricter types
+    type?: string;
+}
+
+export interface RecordJudgeInfo {
+    score: number;
+    memory: number;
+    time: number;
+    judgeTexts: (string | JudgeMessage)[];
+    compilerTexts: string[];
+    testCases: Required<TestCase>[];
+    /** judge uid */
+    judger: number;
+    judgeAt: Date;
+    status: number;
+    subtasks?: Record<number, SubtaskResult>;
+}
+
+export interface RecordPayload extends RecordJudgeInfo {
+    domainId: string;
+    pid: number;
+    uid: number;
+    lang: string;
+    code: string;
+    rejudged: boolean;
+    source?: string;
+    progress?: number;
+    /** pretest */
+    input?: string | string[];
+    /** hack target rid */
+    hackTarget?: string;
+    /** 0 if pretest&script */
+    contest?: string;
+
+    files?: Record<string, string>;
+}
+
+export interface JudgeRequest extends Omit<RecordPayload, 'testCases'> {
+    priority: number;
+    type: 'judge' | 'generate';
+    rid: string;
+    config: ProblemConfigFile;
+    meta: JudgeMeta;
+    data: FileInfo[];
+    source: string;
+    trusted: boolean;
+}
+
+export interface TestCase {
+    id?: number;
+    subtaskId?: number;
+    score?: number;
+    time: number;
+    memory: number;
+    status: number;
+    message: string;
+}
+
+export interface JudgeMessage {
+    message: string;
+    params?: string[];
+    stack?: string;
+}
+
+export interface SubtaskResult {
+    type: SubtaskType;
+    score: number;
+    status: number;
+}
+
+export interface JudgeResultBody {
+    key: string;
+    domainId: string;
+    rid: string;
+    judger?: number;
+    progress?: number;
+    addProgress?: number;
+    case?: TestCase;
+    cases?: TestCase[];
+    status?: number;
+    score?: number;
+    /** in miliseconds */
+    time?: number;
+    /** in kilobytes */
+    memory?: number;
+    message?: string | JudgeMessage;
+    compilerText?: string;
+    nop?: boolean;
+    subtasks?: Record<number, SubtaskResult>;
+}