@xcpcio/core 0.52.0 → 0.53.0

package/dist/index.d.cts

@@ -0,0 +1,519 @@
+import { TimeUnit, SubmissionReaction, SubmissionStatus, Submission as Submission$1, Submissions as Submissions$1, BalloonColor, Problem as Problem$1, Problems as Problems$1, CalculationOfPenalty, Image, Team as Team$1, Teams as Teams$1, Lang, StatusTimeDisplay, MedalPreset, BannerMode, ContestState, Contest as Contest$1, ContestIndex as ContestIndex$1, IPerson, IRatingHistory, IRatingUser, IRating } from '@xcpcio/types';
+import dayjs from 'dayjs';
+export { default as dayjs } from 'dayjs';
+import * as XLSX from 'xlsx-js-style';
+
+declare enum MedalType {
+    UNKNOWN = "Unknown",
+    GOLD = "Gold",
+    SILVER = "Silver",
+    BRONZE = "Bronze",
+    HONORABLE = "Honorable"
+}
+declare class Award {
+    medalType: MedalType;
+    minRank: number;
+    maxRank: number;
+    constructor();
+}
+declare function isValidMedalType(medal: MedalType): boolean;
+type Awards = Map<string, Award[]>;
+
+declare class Submission {
+    id: string;
+    teamId: string;
+    problemId: string;
+    timestamp: number;
+    timestampUnit: TimeUnit;
+    time?: number;
+    language?: string;
+    reaction?: SubmissionReaction;
+    status: SubmissionStatus;
+    isIgnore: boolean;
+    isSolved: boolean;
+    isFirstSolved: boolean;
+    constructor();
+    isAccepted(): boolean;
+    isRejected(): boolean;
+    isPending(): boolean;
+    isNotCalculatedPenaltyStatus(): boolean;
+    get timestampToMinute(): number;
+    get timestampToSecond(): number;
+    get timestampDisplayFormatWithSecond(): string;
+    get timestampDisplayFormatWithMilliSecond(): string;
+    static compare(lhs: Submission, rhs: Submission): number;
+}
+type Submissions = Array<Submission>;
+declare function createSubmission(submissionJSON: Submission$1): Submission;
+declare function createSubmissions(submissionsJSON: Submissions$1): Submissions;
+
+declare class ProblemStatistics {
+    acceptedNum: number;
+    rejectedNum: number;
+    pendingNum: number;
+    submittedNum: number;
+    attemptedNum: number;
+    ignoreNum: number;
+    firstSolveSubmissions: Submissions;
+    lastSolveSubmissions: Submissions;
+    se: number;
+    constructor();
+    reset(): void;
+    get dirt(): number;
+    calcSE(totalTeams: number): number;
+}
+declare class Problem {
+    id: string;
+    label: string;
+    name: string;
+    timeLimit?: string;
+    memoryLimit?: string;
+    balloonColor: BalloonColor;
+    statistics: ProblemStatistics;
+    constructor();
+}
+type Problems = Array<Problem>;
+declare function createProblem(problemJSON: Problem$1): Problem;
+declare function createProblems(problemsJSON: Problems$1): Problems;
+declare function createProblemsByProblemIds(problemIds: string[], balloonColors?: BalloonColor[]): Problems;
+declare class TeamProblemStatistics {
+    isFirstSolved: boolean;
+    isSolved: boolean;
+    solvedTimestamp: number;
+    isSubmitted: boolean;
+    lastSubmitTimestamp: number;
+    failedCount: number;
+    pendingCount: number;
+    ignoreCount: number;
+    totalCount: number;
+    submissions: Submissions;
+    problem: Problem;
+    contestPenalty: number;
+    constructor(options?: {
+        teamProblemStatistics?: TeamProblemStatistics;
+    });
+    get isAccepted(): boolean;
+    get isWrongAnswer(): boolean;
+    get isPending(): boolean;
+    get isUnSubmitted(): boolean;
+    get solvedTimestampToMinute(): number;
+    get penalty(): number;
+    get penaltyToMinute(): number;
+    get penaltyInSecond(): number;
+}
+
+declare class ContestOptions {
+    calculationOfPenalty: CalculationOfPenalty;
+    submissionTimestampUnit: TimeUnit;
+    submissionHasTimeField: boolean;
+    submissionHasLanguageField: boolean;
+    submissionEnableActionField: boolean;
+    constructor();
+}
+
+declare class PlaceChartPointData {
+    timePoint: number;
+    rank: number;
+    lastSolvedProblem: Problem | null;
+    constructor();
+}
+declare class Team {
+    id: string;
+    name: string;
+    organization: string;
+    badge?: Image;
+    group: Array<string>;
+    tag: Array<string>;
+    coach?: string | Array<string>;
+    members?: string | Array<string>;
+    rank: number;
+    originalRank: number;
+    organizationRank: number;
+    solvedProblemNum: number;
+    attemptedProblemNum: number;
+    lastSolvedProblem: Problem | null;
+    lastSolvedProblemStatistics: TeamProblemStatistics | null;
+    penalty: number;
+    problemStatistics: Array<TeamProblemStatistics>;
+    problemStatisticsMap: Map<string, TeamProblemStatistics>;
+    submissions: Submissions;
+    placeChartPoints: Array<PlaceChartPointData>;
+    awards: MedalType[];
+    location?: string;
+    icpcID?: string;
+    se: number;
+    constructor();
+    reset(): void;
+    get penaltyToMinute(): number;
+    get isUnofficial(): boolean;
+    get isGirl(): boolean;
+    get membersToArray(): string[];
+    get membersToString(): string | undefined;
+    get isEffectiveTeam(): boolean;
+    get dirt(): number;
+    calcSE(totalTeams: number): number;
+    calcSolvedData(options: ContestOptions): void;
+    calcAwards(awards?: Award[]): void;
+    isEqualRank(otherTeam: Team): boolean;
+    postProcessPlaceChartPoints(): void;
+    static compare(lhs: Team, rhs: Team): number;
+}
+type Teams = Array<Team>;
+declare function createTeam(teamJSON: Team$1): Team;
+declare function createTeams(teamsJSON: Teams$1): Teams;
+
+declare class Balloon {
+    problem: Problem;
+    team: Team;
+    submission: Submission;
+    constructor();
+    get key(): string;
+    static compare(lhs: Balloon, rhs: Balloon): number;
+}
+type Balloons = Array<Balloon>;
+
+interface SelectOptionItem {
+    value: string;
+    text: string;
+}
+
+declare enum GiantsType {
+    BLUE = 0,
+    RED = 1
+}
+declare class Giants {
+    type: GiantsType;
+    name: string;
+    filterOrganizations: Array<SelectOptionItem>;
+    filterOrganizationMap: Map<string, SelectOptionItem>;
+    filterTeams: Array<SelectOptionItem>;
+    filterTeamMap: Map<string, SelectOptionItem>;
+    teams: Array<Team>;
+    constructor(type?: GiantsType);
+    setFilterOrganizations(filterOrganizations: Array<SelectOptionItem>): void;
+    setFilterTeams(filterTeams: Array<SelectOptionItem>): void;
+    refreshName(): string;
+    get totalSolvedProblemNum(): number;
+    get totalPenalty(): number;
+    get totalPenaltyToString(): string;
+    toJSON(): {
+        type: GiantsType;
+        name: string;
+        filterOrganizations: SelectOptionItem[];
+        filterTeams: SelectOptionItem[];
+    };
+}
+declare class BattleOfGiants {
+    enable: boolean;
+    topX: number;
+    equalTeams: boolean;
+    persist: boolean;
+    blueTeam: Giants;
+    redTeam: Giants;
+    constructor();
+    ToBase64(): string;
+    FromBase64(base64: string): void;
+}
+
+declare class Group {
+    names: Map<Lang, string>;
+    defaultLang: Lang;
+    isDefault: boolean;
+    constructor();
+}
+
+declare function calcDirt(attemptedNum: number, solvedNum: number): number;
+
+declare function getWhiteOrBlackColorV1(background: string): "#000" | "#fff";
+declare function getWhiteOrBlackColor(background: string): "#000" | "#fff";
+
+declare function createDayJS(time?: Date | string | number | undefined): dayjs.Dayjs;
+declare function getTimestamp(time: number | dayjs.Dayjs): number;
+declare function getTimeDiff(seconds: number): string;
+
+declare class Contest {
+    id: string;
+    name: string;
+    startTime: dayjs.Dayjs;
+    endTime: dayjs.Dayjs;
+    freezeTime: dayjs.Dayjs;
+    replayStartTime?: dayjs.Dayjs;
+    replayEndTime?: dayjs.Dayjs;
+    replayFreezeTime?: dayjs.Dayjs;
+    replayNowTime?: dayjs.Dayjs;
+    replayContestStartTimestamp?: number;
+    totalDurationTimestamp: number;
+    freezeDurationTimestamp: number;
+    unFreezeDurationTimestamp: number;
+    penalty: number;
+    problems: Problems;
+    problemsMap: Map<string, Problem>;
+    statusTimeDisplay: StatusTimeDisplay;
+    badge?: string;
+    medal?: Record<string, Record<string, number>> | MedalPreset;
+    awards?: Awards;
+    organization?: string;
+    group: Map<string, Group>;
+    tag: Map<string, string>;
+    logo?: Image;
+    banner?: Image;
+    bannerMode?: BannerMode;
+    boardLink?: string;
+    options: ContestOptions;
+    constructor();
+    getStartTime(): dayjs.Dayjs;
+    getEndTime(): dayjs.Dayjs;
+    getFreezeTime(): dayjs.Dayjs;
+    getContestDuration(timeFormat?: string): string;
+    getContestState(nowTime?: Date): ContestState;
+    getContestPendingTime(nowTime?: Date): string;
+    getContestElapsedTime(nowTime?: Date): string;
+    getContestRemainingTime(nowTime?: Date): string;
+    getContestProgressRatio(nowTime?: Date): number;
+    isEnableAwards(group: string): boolean;
+    resetReplayTime(): void;
+    setReplayTime(replayStartTimestamp: number): void;
+}
+declare function createContest(contestJSON: Contest$1): Contest;
+
+declare class ContestIndexConfig {
+    contestName: string;
+    startTime: dayjs.Dayjs;
+    endTime: dayjs.Dayjs;
+    freezeTime: dayjs.Dayjs;
+    totalDurationTimestamp: number;
+    freezeDurationTimestamp: number;
+    unFreezeDurationTimestamp: number;
+    logo?: Image;
+    constructor();
+}
+declare class ContestIndex {
+    contest: Contest;
+    boardLink: string;
+    constructor();
+}
+type ContestIndexList = Array<ContestIndex>;
+declare function createContestIndex(contestIndexJSON: ContestIndex$1): ContestIndex;
+declare function createContestIndexList(contestListJSON: any): ContestIndexList;
+
+declare class RankStatistics {
+    teamSolvedNum: Array<number>;
+    teamSolvedNumIndex: Array<number>;
+    maxSolvedProblems: number;
+    effectiveTeamNum: number;
+    totalTeamNum: number;
+    constructor();
+    reset(): void;
+    getTeamSolvedNumIndex(solvedNum: number): number;
+}
+
+declare class RankOptions {
+    enableFilterSubmissionsByTimestamp: boolean;
+    width: number;
+    timestamp: number;
+    enableFilterTeamsByGroup: boolean;
+    group: string;
+    filterOrganizations: Array<SelectOptionItem>;
+    filterOrganizationMap: Map<string, SelectOptionItem>;
+    filterTeams: Array<SelectOptionItem>;
+    filterTeamMap: Map<string, SelectOptionItem>;
+    enableAnimatedSubmissions: boolean;
+    battleOfGiants: BattleOfGiants;
+    constructor();
+    setSelf(self: RankOptions): void;
+    setWidth(width: number, contest: Contest): void;
+    disableFilterSubmissionByTimestamp(): void;
+    setGroup(group: string): void;
+    disableFilterTeamsByGroup(): void;
+    setFilterOrganizations(filterOrganizations: Array<SelectOptionItem>): void;
+    setFilterTeams(filterTeams: Array<SelectOptionItem>): void;
+    isNeedReBuildRank(nextRankOptions: RankOptions): boolean;
+}
+declare class Rank {
+    readonly contest: Contest;
+    teams: Teams;
+    teamsMap: Map<string, Team>;
+    submissions: Submissions;
+    submissionsMap: Map<string, Submission>;
+    organizations: Array<string>;
+    originTeams: Teams;
+    rankStatistics: RankStatistics;
+    options: RankOptions;
+    balloons: Balloons;
+    languages: Array<string>;
+    statuses: Array<SubmissionStatus>;
+    constructor(contest: Contest, teams: Teams, submissions: Submissions);
+    cleanRank(): void;
+    buildRank(): this;
+    buildTeamRank(): void;
+    buildOrgRank(): void;
+    buildOrganizations(): string[];
+    buildAwards(): void;
+    filterTeamByOrg(team: Team): boolean;
+    getSubmissions(): Submissions;
+    buildBalloons(): void;
+    setReplayTime(replayStartTimestamp: number): void;
+}
+type Ranks = Array<Rank>;
+
+declare class CodeforcesGymGhostDATConverter {
+    constructor();
+    convert(rank: Rank): string;
+    private submissionStatusToCodeforcesGymDatStatus;
+}
+
+declare class GeneralExcelConverter {
+    constructor();
+    convert(oriRank: Rank): XLSX.WorkBook;
+    convertAndWrite(rank: Rank, filename: string): any;
+    private convertToSheet;
+    private convertToAoa;
+}
+
+declare class ICPCStandingsCsvConverter {
+    constructor();
+    convert(oriRank: Rank): string;
+    private getMedalCitation;
+}
+
+declare function getImageSource(image: Image, asset_host?: string): string;
+
+declare class Person {
+    name: string;
+    constructor(name?: string);
+    toJSON(): IPerson;
+    static fromJSON(iPerson: IPerson | string): Person;
+}
+type Persons = Array<Person>;
+declare function createPersons(iPersons: string | Array<string>): Persons;
+
+declare class RatingHistory {
+    rank: number;
+    rating: number;
+    teamName: string;
+    organization: string;
+    members: Persons;
+    coaches: Persons;
+    contestID: string;
+    contestName: string;
+    contestLink: string;
+    contestTime: dayjs.Dayjs;
+    constructor();
+    toJSON(): IRatingHistory;
+    static fromJSON(iRatingHistory: IRatingHistory | string): RatingHistory;
+}
+type RatingHistories = Array<RatingHistory>;
+
+declare class RatingUser {
+    id: string;
+    name: string;
+    organization: string;
+    members: Persons;
+    coaches: Persons;
+    rating: number;
+    minRating: number;
+    maxRating: number;
+    rank: number;
+    oldRating: number;
+    seed: number;
+    delta: number;
+    ratingHistories: RatingHistories;
+    constructor();
+    UpdateRating(rating: number): void;
+    toJSON(): IRatingUser;
+    static fromJSON(iRatingUser: IRatingUser | string): RatingUser;
+}
+type RatingUsers = Array<RatingUser>;
+type RatingUserMap = Map<string, RatingUser>;
+
+declare class Rating {
+    id: string;
+    name: string;
+    baseRating: number;
+    contestIDs: string[];
+    users: RatingUsers;
+    ranks: Ranks;
+    userMap: RatingUserMap;
+    constructor();
+    buildRating(): void;
+    generateTeamId(t: Team): string;
+    toJSON(): IRating;
+    static fromJSON(iRating: IRating | string): Rating;
+}
+
+declare class RatingCalculator {
+    users: RatingUsers;
+    constructor();
+    calculate(): void;
+    private calcP;
+    private getExSeed;
+    private calcRating;
+    private calculateInternal;
+}
+
+declare enum RatingLevel {
+    NEWBIE = "NEWBIE",
+    PUPIL = "PUPIL",
+    SPECIALIST = "SPECIALIST",
+    EXPERT = "EXPERT",
+    CANDIDATE_MASTER = "CANDIDATE_MASTER",
+    MASTER = "MASTER",
+    INTERNATIONAL_MASTER = "INTERNATIONAL_MASTER",
+    GRANDMASTER = "GRANDMASTER",
+    INTERNATIONAL_GRANDMASTER = "INTERNATIONAL_GRANDMASTER",
+    LEGENDARY_GRANDMASTER = "LEGENDARY_GRANDMASTER"
+}
+declare const RatingLevelToString: {
+    [key in RatingLevel]: string;
+};
+declare class RatingUtility {
+    static getRatingLevel(rating: number): RatingLevel;
+    static getRatingLevelClass(ratingLevel: RatingLevel | number): string;
+}
+
+declare class ResolverOperation {
+    id: number;
+    team: Team;
+    problemIx: number;
+    beforeTeamProblemStatistics: TeamProblemStatistics;
+    afterTeamProblemStatistics: TeamProblemStatistics;
+    constructor();
+}
+
+declare class Resolver extends Rank {
+    finalRank: Rank;
+    operations: Array<ResolverOperation>;
+    beforeFreezeSubmissions: Submissions;
+    afterFreezeSubmissions: Submissions;
+    constructor(contest: Contest, teams: Teams, submissions: Submissions);
+    buildResolver(): void;
+}
+
+declare class ResolverVue extends Resolver {
+    readonly FLASHING_TIME_MS = 100;
+    readonly ROLLING_TIME_MS = 600;
+    maxIndex: number;
+    currentIndex: number;
+    maxOpIndex: number;
+    currentOpIndex: number;
+    oldRank: number;
+    newRank: number;
+    currentTeamId: string;
+    currentProblemIndex: number;
+    problemFlashingEnded: boolean;
+    duringAnimation: boolean;
+    startScrollUp: boolean;
+    startScrollDown: boolean;
+    constructor(contest: Contest, teams: Teams, submissions: Submissions);
+    buildResolver(): void;
+    next(): void;
+    rewind(): void;
+}
+
+declare function stringToSubmissionStatus(status: string): SubmissionStatus;
+declare function isAccepted(status: SubmissionStatus): boolean;
+declare function isRejected(status: SubmissionStatus): boolean;
+declare function isPending(status: SubmissionStatus): boolean;
+declare function isNotCalculatedPenaltyStatus(status: SubmissionStatus): boolean;
+
+export { Award, type Awards, Balloon, type Balloons, BattleOfGiants, CodeforcesGymGhostDATConverter, Contest, ContestIndex, ContestIndexConfig, type ContestIndexList, ContestOptions, GeneralExcelConverter, Giants, GiantsType, ICPCStandingsCsvConverter, MedalType, Person, type Persons, PlaceChartPointData, Problem, ProblemStatistics, type Problems, Rank, RankOptions, RankStatistics, type Ranks, Rating, RatingCalculator, type RatingHistories, RatingHistory, RatingLevel, RatingLevelToString, RatingUser, type RatingUserMap, type RatingUsers, RatingUtility, Resolver, ResolverVue, type SelectOptionItem, Submission, type Submissions, Team, TeamProblemStatistics, type Teams, calcDirt, createContest, createContestIndex, createContestIndexList, createDayJS, createPersons, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, getWhiteOrBlackColor, getWhiteOrBlackColorV1, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, isValidMedalType, stringToSubmissionStatus };