@algoux/standard-ranklist-utils 0.1.1 → 0.2.0

package/dist/ranklist.js

@@ -1,492 +0,0 @@
-import semver from 'semver';
-import BigNumber from 'bignumber.js';
-import { MIN_REGEN_SUPPORTED_VERSION } from './constants';
-import { formatTimeDuration } from './formatters';
-export function canRegenerateRanklist(ranklist) {
-    try {
-        if (!semver.gte(ranklist.version, MIN_REGEN_SUPPORTED_VERSION)) {
-            return false;
-        }
-        if (ranklist.sorter?.algorithm !== 'ICPC') {
-            return false;
-        }
-    }
-    catch (e) {
-        return false;
-    }
-    return true;
-}
-export function getSortedCalculatedRawSolutions(rows) {
-    const solutions = [];
-    for (const row of rows) {
-        const { user, statuses } = row;
-        const userId = (user.id && `${user.id}`) || `${typeof user.name === 'string' ? user.name : JSON.stringify(user.name)}`;
-        statuses.forEach((status, index) => {
-            if (Array.isArray(status.solutions) && status.solutions.length) {
-                solutions.push(...status.solutions.map((solution) => [userId, index, solution.result, solution.time]));
-            }
-            else if (status.result && status.time?.[0]) {
-                // use status.result as partial solutions
-                if (status.result === 'AC' || status.result === 'FB') {
-                    // push a series of mocked rejected solutions based on tries
-                    for (let i = 1; i < (status.tries || 0); i++) {
-                        solutions.push([userId, index, 'RJ', status.time]);
-                    }
-                    solutions.push([userId, index, status.result, status.time]);
-                }
-            }
-        });
-    }
-    return solutions.sort((a, b) => {
-        const ta = a[3];
-        const tb = b[3];
-        // if time duration unit is same, directly compare their value; else convert to minimum unit to compare
-        const timeComp = ta[1] === tb[1] ? ta[0] - tb[0] : formatTimeDuration(ta) - formatTimeDuration(tb);
-        if (timeComp !== 0) {
-            return timeComp;
-        }
-        const resultValue = {
-            FB: 998,
-            AC: 999,
-            '?': 1000,
-        };
-        const resultA = resultValue[a[2]] || 0;
-        const resultB = resultValue[b[2]] || 0;
-        return resultA - resultB;
-    });
-}
-export function filterSolutionsUntil(solutions, time) {
-    const timeValue = formatTimeDuration(time);
-    const check = (tetrad) => formatTimeDuration(tetrad[3]) <= timeValue;
-    let lastIndex = -1;
-    let low = 0;
-    let high = solutions.length - 1;
-    while (low <= high) {
-        const mid = (low + high) >> 1;
-        if (check(solutions[mid])) {
-            lastIndex = mid;
-            low = mid + 1;
-        }
-        else {
-            high = mid - 1;
-        }
-    }
-    return solutions.slice(0, lastIndex + 1);
-}
-export function sortRows(rows) {
-    rows.sort((a, b) => {
-        if (a.score.value !== b.score.value) {
-            return b.score.value - a.score.value;
-        }
-        return formatTimeDuration(a.score.time) - formatTimeDuration(b.score.time);
-    });
-    return rows;
-}
-export function regenerateRanklistBySolutions(originalRanklist, solutions) {
-    if (!canRegenerateRanklist(originalRanklist)) {
-        throw new Error('The ranklist is not supported to regenerate');
-    }
-    const sorterConfig = {
-        penalty: [20, 'min'],
-        noPenaltyResults: ['FB', 'AC', '?', 'CE', 'UKE', null],
-        timeRounding: 'floor',
-        ...JSON.parse(JSON.stringify(originalRanklist.sorter?.config || {})),
-    };
-    const ranklist = {
-        ...originalRanklist,
-        rows: [],
-    };
-    const rows = [];
-    const userRowMap = new Map();
-    const problemCount = originalRanklist.problems.length;
-    originalRanklist.rows.forEach((row) => {
-        const userId = (row.user.id && `${row.user.id}`) ||
-            `${typeof row.user.name === 'string' ? row.user.name : JSON.stringify(row.user.name)}`;
-        userRowMap.set(userId, {
-            user: row.user,
-            score: {
-                value: 0,
-            },
-            statuses: new Array(problemCount).fill(null).map(() => ({ result: null, solutions: [] })),
-        });
-    });
-    for (const tetrad of solutions) {
-        const [userId, problemIndex, result, time] = tetrad;
-        let row = userRowMap.get(userId);
-        if (!row) {
-            console.error(`Invalid user id ${userId} found when regenerating ranklist`);
-            break;
-        }
-        const status = row.statuses[problemIndex];
-        status.solutions.push({ result, time });
-    }
-    const problemAcceptedCount = new Array(problemCount).fill(0);
-    const problemSubmittedCount = new Array(problemCount).fill(0);
-    for (const row of userRowMap.values()) {
-        const { statuses } = row;
-        let scoreValue = 0;
-        let totalTimeMs = 0;
-        for (let i = 0; i < statuses.length; ++i) {
-            const status = statuses[i];
-            // calculate for each problem
-            const solutions = status.solutions;
-            for (const solution of solutions) {
-                if (!solution.result) {
-                    continue;
-                }
-                if (solution.result === '?') {
-                    status.result = solution.result;
-                    status.tries = (status.tries || 0) + 1;
-                    problemSubmittedCount[i] += 1;
-                    continue;
-                }
-                if (solution.result === 'AC' || solution.result === 'FB') {
-                    status.result = solution.result;
-                    status.time = solution.time;
-                    status.tries = (status.tries || 0) + 1;
-                    problemAcceptedCount[i] += 1;
-                    problemSubmittedCount[i] += 1;
-                    break;
-                }
-                // @ts-ignore
-                if ((sorterConfig.noPenaltyResults || []).includes(solution.result)) {
-                    continue;
-                }
-                status.result = 'RJ';
-                status.tries = (status.tries || 0) + 1;
-                problemSubmittedCount[i] += 1;
-            }
-            if (status.result === 'AC' || status.result === 'FB') {
-                const targetTime = [
-                    formatTimeDuration(status.time, sorterConfig.timePrecision || 'ms', sorterConfig.timeRounding === 'ceil'
-                        ? Math.ceil
-                        : sorterConfig.timeRounding === 'round'
-                            ? Math.round
-                            : Math.floor),
-                    sorterConfig.timePrecision || 'ms',
-                ];
-                scoreValue += 1;
-                totalTimeMs +=
-                    formatTimeDuration(targetTime, 'ms') + (status.tries - 1) * formatTimeDuration(sorterConfig.penalty, 'ms');
-            }
-        }
-        row.score = {
-            value: scoreValue,
-            time: [totalTimeMs, 'ms'],
-        };
-        rows.push(row);
-    }
-    ranklist.rows = sortRows(rows);
-    ranklist.problems.forEach((problem, index) => {
-        if (!problem.statistics) {
-            problem.statistics = {
-                accepted: 0,
-                submitted: 0,
-            };
-        }
-        problem.statistics.accepted = problemAcceptedCount[index];
-        problem.statistics.submitted = problemSubmittedCount[index];
-    });
-    return ranklist;
-}
-export function regenerateRowsByIncrementalSolutions(originalRanklist, solutions) {
-    if (!canRegenerateRanklist(originalRanklist)) {
-        throw new Error('The ranklist is not supported to regenerate');
-    }
-    const sorterConfig = {
-        penalty: [20, 'min'],
-        noPenaltyResults: ['FB', 'AC', '?', 'CE', 'UKE', null],
-        timeRounding: 'floor',
-        ...JSON.parse(JSON.stringify(originalRanklist.sorter?.config || {})),
-    };
-    const userRowIndexMap = new Map();
-    const rows = [...originalRanklist.rows];
-    rows.forEach((row, index) => {
-        const userId = (row.user.id && `${row.user.id}`) ||
-            `${typeof row.user.name === 'string' ? row.user.name : JSON.stringify(row.user.name)}`;
-        userRowIndexMap.set(userId, index);
-    });
-    const clonedRowMap = new Set();
-    const clonedRowStatusMap = new Set();
-    for (const tetrad of solutions) {
-        const [userId, problemIndex, result, time] = tetrad;
-        let rowIndex = userRowIndexMap.get(userId);
-        if (rowIndex === undefined) {
-            console.error(`Invalid user id ${userId} found when regenerating ranklist`);
-            break;
-        }
-        let row = rows[rowIndex];
-        if (!clonedRowMap.has(userId)) {
-            row = { ...row };
-            row.score = { ...row.score };
-            row.statuses = [...row.statuses];
-            rows[rowIndex] = row;
-            clonedRowMap.add(userId);
-        }
-        if (!clonedRowStatusMap.has(`${userId}_${problemIndex}`)) {
-            row.statuses[problemIndex] = { ...row.statuses[problemIndex] };
-            row.statuses[problemIndex].solutions = [...row.statuses[problemIndex].solutions];
-            clonedRowStatusMap.add(`${userId}_${problemIndex}`);
-        }
-        const status = row.statuses[problemIndex];
-        status.solutions.push({ result, time });
-        if (status.result === 'AC' || status.result === 'FB') {
-            continue;
-        }
-        if (result === '?') {
-            status.result = result;
-            status.tries = (status.tries || 0) + 1;
-            continue;
-        }
-        if (result === 'AC' || result === 'FB') {
-            status.result = result;
-            status.time = time;
-            status.tries = (status.tries || 0) + 1;
-            row.score.value += 1;
-            const targetTime = [
-                formatTimeDuration(status.time, sorterConfig.timePrecision || 'ms', sorterConfig.timeRounding === 'ceil'
-                    ? Math.ceil
-                    : sorterConfig.timeRounding === 'round'
-                        ? Math.round
-                        : Math.floor),
-                sorterConfig.timePrecision || 'ms',
-            ];
-            const totalTime = formatTimeDuration(row.score.time, 'ms') || 0;
-            row.score.time = [
-                totalTime +
-                    formatTimeDuration(targetTime, 'ms') +
-                    (status.tries - 1) * formatTimeDuration(sorterConfig.penalty, 'ms'),
-                'ms',
-            ];
-            continue;
-        }
-        // @ts-ignore
-        if ((sorterConfig.noPenaltyResults || []).includes(result)) {
-            continue;
-        }
-        status.result = 'RJ';
-        status.tries = (status.tries || 0) + 1;
-    }
-    return sortRows(rows);
-}
-function genSeriesCalcFns(series, rows, ranks, officialRanks) {
-    const fallbackSeriesCalcFn = () => ({
-        rank: null,
-        segmentIndex: null,
-    });
-    const fns = series.map((seriesConfig) => {
-        const { rule } = seriesConfig;
-        if (!rule) {
-            return fallbackSeriesCalcFn;
-        }
-        const { preset } = rule;
-        switch (preset) {
-            case 'Normal': {
-                const options = rule.options;
-                return (row, index) => {
-                    if (options?.includeOfficialOnly && row.user.official === false) {
-                        return {
-                            rank: null,
-                            segmentIndex: null,
-                        };
-                    }
-                    return {
-                        rank: options?.includeOfficialOnly ? officialRanks[index] : ranks[index],
-                        segmentIndex: null,
-                    };
-                };
-            }
-            case 'UniqByUserField': {
-                const options = rule.options;
-                const field = options?.field;
-                const assignedRanksMap = new Map();
-                const valueSet = new Set();
-                const stringify = (v) => (typeof v === 'object' ? JSON.stringify(v) : `${v}`);
-                let lastOuterRank = 0;
-                let lastRank = 0;
-                rows.forEach((row, index) => {
-                    if (options.includeOfficialOnly && row.user.official === false) {
-                        return;
-                    }
-                    const value = stringify(row.user[field]);
-                    if (value && !valueSet.has(value)) {
-                        const outerRank = options.includeOfficialOnly ? officialRanks[index] : ranks[index];
-                        valueSet.add(value);
-                        if (outerRank !== lastOuterRank) {
-                            lastOuterRank = outerRank;
-                            lastRank = assignedRanksMap.size + 1;
-                            assignedRanksMap.set(index, lastRank);
-                        }
-                        assignedRanksMap.set(index, lastRank);
-                    }
-                });
-                return (row, index) => {
-                    return {
-                        rank: assignedRanksMap.get(index) ?? null,
-                        segmentIndex: null,
-                    };
-                };
-            }
-            case 'ICPC': {
-                const options = rule.options;
-                let filteredRows = rows.filter((row) => row.user.official === undefined || row.user.official === true);
-                let filteredOfficialRanks = [...officialRanks];
-                if (options.filter) {
-                    if (Array.isArray(options.filter.byUserFields) && options.filter.byUserFields.length) {
-                        const currentFilteredRows = [];
-                        filteredOfficialRanks = filteredOfficialRanks.map(() => null);
-                        let currentOfficialRank = 0;
-                        let currentOfficialRankOld = 0;
-                        rows.forEach((row, index) => {
-                            const shouldInclude = options.filter.byUserFields.every((filter) => {
-                                const { field, rule } = filter;
-                                const value = row.user[field];
-                                if (value === undefined) {
-                                    return false;
-                                }
-                                return new RegExp(rule).test(`${value}`);
-                            });
-                            if (shouldInclude) {
-                                currentFilteredRows.push(row);
-                                const oldRank = officialRanks[index];
-                                if (oldRank !== null) {
-                                    if (currentOfficialRankOld !== oldRank) {
-                                        currentOfficialRank++;
-                                        currentOfficialRankOld = oldRank;
-                                    }
-                                    filteredOfficialRanks[index] = currentOfficialRank;
-                                }
-                                else {
-                                    filteredOfficialRanks[index] = null;
-                                }
-                            }
-                        });
-                        filteredRows = currentFilteredRows;
-                    }
-                }
-                const usingEndpointRules = [];
-                let noTied = false;
-                if (options.ratio) {
-                    const { value, rounding = 'ceil', denominator = 'all' } = options.ratio;
-                    const officialRows = filteredRows;
-                    let total = denominator === 'submitted'
-                        ? officialRows.filter((row) => !row.statuses.every((s) => s.result === null)).length
-                        : officialRows.length;
-                    const accValues = [];
-                    for (let i = 0; i < value.length; i++) {
-                        if (i === 0) {
-                            accValues[i] = new BigNumber(value[i]);
-                        }
-                        else {
-                            accValues[i] = accValues[i - 1].plus(new BigNumber(value[i]));
-                        }
-                    }
-                    const segmentRawEndpoints = accValues.map((v) => v.times(total).toNumber());
-                    usingEndpointRules.push(segmentRawEndpoints.map((v) => {
-                        return rounding === 'floor' ? Math.floor(v) : rounding === 'round' ? Math.round(v) : Math.ceil(v);
-                    }));
-                    if (options.ratio.noTied) {
-                        noTied = true;
-                    }
-                }
-                if (options.count) {
-                    const { value } = options.count;
-                    const accValues = [];
-                    for (let i = 0; i < value.length; i++) {
-                        accValues[i] = (i > 0 ? accValues[i - 1] : 0) + value[i];
-                    }
-                    usingEndpointRules.push(accValues);
-                    if (options.count.noTied) {
-                        noTied = true;
-                    }
-                }
-                const officialRanksNoTied = [];
-                let currentOfficialRank = 0;
-                for (let i = 0; i < filteredOfficialRanks.length; i++) {
-                    officialRanksNoTied.push(filteredOfficialRanks[i] === null ? null : ++currentOfficialRank);
-                }
-                return (row, index) => {
-                    if (row.user.official === false || !filteredRows.find((r) => r.user.id === row.user.id)) {
-                        return {
-                            rank: null,
-                            segmentIndex: null,
-                        };
-                    }
-                    const usingSegmentIndex = (seriesConfig.segments || []).findIndex((_, segIndex) => {
-                        return usingEndpointRules
-                            .map((e) => e[segIndex])
-                            .every((endpoints) => (noTied ? officialRanksNoTied : filteredOfficialRanks)[index] <= endpoints);
-                    });
-                    return {
-                        rank: filteredOfficialRanks[index],
-                        segmentIndex: usingSegmentIndex > -1 ? usingSegmentIndex : null,
-                    };
-                };
-            }
-            default:
-                console.warn('Unknown series rule preset：', preset);
-                return fallbackSeriesCalcFn;
-        }
-    });
-    return fns;
-}
-function genRowRanks(rows) {
-    const compareScoreEqual = (a, b) => {
-        if (a.value !== b.value) {
-            return false;
-        }
-        const da = a.time ? formatTimeDuration(a.time) : 0;
-        const db = b.time ? formatTimeDuration(b.time) : 0;
-        return da === db;
-    };
-    const genRanks = (rows) => {
-        let ranks = new Array(rows.length).fill(null);
-        for (let i = 0; i < rows.length; ++i) {
-            if (i === 0) {
-                ranks[i] = 1;
-                continue;
-            }
-            if (compareScoreEqual(rows[i].score, rows[i - 1].score)) {
-                ranks[i] = ranks[i - 1];
-            }
-            else {
-                ranks[i] = i + 1;
-            }
-        }
-        return ranks;
-    };
-    const ranks = genRanks(rows);
-    const officialPartialRows = [];
-    const officialIndexBackMap = new Map();
-    rows.forEach((row, index) => {
-        if (row.user.official !== false) {
-            officialIndexBackMap.set(index, officialPartialRows.length);
-            officialPartialRows.push(row);
-        }
-    });
-    const officialPartialRanks = genRanks(officialPartialRows);
-    const officialRanks = new Array(rows.length)
-        .fill(null)
-        .map((_, index) => officialIndexBackMap.get(index) === undefined ? null : officialPartialRanks[officialIndexBackMap.get(index)]);
-    return {
-        ranks,
-        officialRanks,
-    };
-}
-export function convertToStaticRanklist(ranklist) {
-    if (!ranklist) {
-        return ranklist;
-    }
-    const { series, rows } = ranklist;
-    const rowRanks = genRowRanks(rows);
-    const seriesCalcFns = genSeriesCalcFns(series, rows, rowRanks.ranks, rowRanks.officialRanks);
-    return {
-        ...ranklist,
-        rows: rows.map((row, index) => {
-            return {
-                ...row,
-                rankValues: seriesCalcFns.map((fn) => fn(row, index)),
-            };
-        }),
-    };
-}

package/dist/resolvers.d.ts

@@ -1,25 +0,0 @@
-import type * as srk from '@algoux/standard-ranklist';
-import { ThemeColor } from './types';
-export declare function resolveText(text: srk.Text | undefined): string;
-/**
- * Parse contributor string to an object which contains name, email (optional) and url (optional).
- * @param contributor
- * @returns parsed contributor object
- * @example
- * 'name <mail@example.com> (http://example.com)' -> { name: 'name', email: 'mail@example.com', url: 'http://example.com' }
- * 'name' -> { name: 'name' }
- * 'name <mail@example.com>' -> { name: 'name', email: 'mail@example.com' }
- * 'name (http://example.com)' -> { name: 'name', url: 'http://example.com' }
- * 'John Smith (http://example.com)' -> { name: 'John Smith', url: 'http://example.com' }
- */
-export declare function resolveContributor(contributor: srk.Contributor | undefined): {
-    name: string;
-    email?: string;
-    url?: string;
-} | null;
-export declare function resolveColor(color: srk.Color): string | undefined;
-export declare function resolveThemeColor(themeColor: srk.ThemeColor): ThemeColor;
-export declare function resolveStyle(style: srk.Style): {
-    textColor: ThemeColor;
-    backgroundColor: ThemeColor;
-};

package/dist/resolvers.js

@@ -1,98 +0,0 @@
-// @ts-ignore
-import TEXTColor from 'textcolor';
-import { lookup as langLookup } from 'bcp-47-match';
-import { EnumTheme } from './enums';
-export function resolveText(text) {
-    if (text === undefined) {
-        return '';
-    }
-    if (typeof text === 'string') {
-        return text;
-    }
-    else {
-        const langs = Object.keys(text)
-            .filter((k) => k && k !== 'fallback')
-            .sort()
-            .reverse();
-        const userLangs = (typeof navigator !== 'undefined' && [...navigator.languages]) || [];
-        const usingLang = langLookup(userLangs, langs) || 'fallback';
-        return text[usingLang] ?? '';
-    }
-}
-/**
- * Parse contributor string to an object which contains name, email (optional) and url (optional).
- * @param contributor
- * @returns parsed contributor object
- * @example
- * 'name <mail@example.com> (http://example.com)' -> { name: 'name', email: 'mail@example.com', url: 'http://example.com' }
- * 'name' -> { name: 'name' }
- * 'name <mail@example.com>' -> { name: 'name', email: 'mail@example.com' }
- * 'name (http://example.com)' -> { name: 'name', url: 'http://example.com' }
- * 'John Smith (http://example.com)' -> { name: 'John Smith', url: 'http://example.com' }
- */
-export function resolveContributor(contributor) {
-    if (!contributor) {
-        return null;
-    }
-    let name = '';
-    let email;
-    let url;
-    const words = contributor.split(' ').map((s) => s.trim());
-    let index = words.length - 1;
-    while (index > 0) {
-        const word = words[index];
-        if (word.startsWith('<') && word.endsWith('>')) {
-            email = word.slice(1, -1);
-            index--;
-            continue;
-        }
-        if (word.startsWith('(') && word.endsWith(')')) {
-            url = word.slice(1, -1);
-            index--;
-            continue;
-        }
-        break;
-    }
-    name = words.slice(0, index + 1).join(' ');
-    return { name, email, url };
-}
-export function resolveColor(color) {
-    if (Array.isArray(color)) {
-        return `rgba(${color[0]},${color[1]},${color[2]},${color[3]})`;
-    }
-    else if (color) {
-        return color;
-    }
-    return undefined;
-}
-export function resolveThemeColor(themeColor) {
-    let light = resolveColor(typeof themeColor === 'string' ? themeColor : themeColor.light);
-    let dark = resolveColor(typeof themeColor === 'string' ? themeColor : themeColor.dark);
-    return {
-        [EnumTheme.light]: light,
-        [EnumTheme.dark]: dark,
-    };
-}
-export function resolveStyle(style) {
-    const { textColor, backgroundColor } = style;
-    let usingTextColor = textColor;
-    // 未指定前景色时，尝试自动适配
-    if (backgroundColor && !textColor) {
-        if (typeof backgroundColor === 'string') {
-            usingTextColor = TEXTColor.findTextColor(backgroundColor);
-        }
-        else {
-            const { light, dark } = backgroundColor;
-            usingTextColor = {
-                light: light && TEXTColor.findTextColor(light),
-                dark: dark && TEXTColor.findTextColor(dark),
-            };
-        }
-    }
-    const textThemeColor = resolveThemeColor(usingTextColor || '');
-    const backgroundThemeColor = resolveThemeColor(backgroundColor || '');
-    return {
-        textColor: textThemeColor,
-        backgroundColor: backgroundThemeColor,
-    };
-}

package/dist/types.d.ts

@@ -1,26 +0,0 @@
-import type * as srk from '@algoux/standard-ranklist';
-import { EnumTheme } from './enums';
-export interface RankValue {
-    /** Rank value initially. If the user is unofficial and rank value equals null, it will be rendered as unofficial mark such as '*'. */
-    rank: number | null;
-    /**
-     * Series segment index which this rank belongs to initially. `null` means this rank does not belong to any segment. `undefined` means it will be calculated automatically (only if the segment's count property exists).
-     * @defaultValue null
-     */
-    segmentIndex?: number | null;
-}
-export type StaticRanklist = Omit<srk.Ranklist, 'rows'> & {
-    rows: Array<srk.RanklistRow & {
-        rankValues: RankValue[];
-    }>;
-};
-export type CalculatedSolutionTetrad = [
-    /** user id */ string,
-    /** problem index */ number,
-    /** result */ Exclude<srk.SolutionResultFull, null> | srk.SolutionResultCustom,
-    /** solution submitted time */ srk.TimeDuration
-];
-export interface ThemeColor {
-    [EnumTheme.light]: string | undefined;
-    [EnumTheme.dark]: string | undefined;
-}

package/dist/types.js

@@ -1 +0,0 @@
-import { EnumTheme } from './enums';