@rasifix/orienteering-utils 2.0.1 → 2.0.3

package/lib/format.d.ts

@@ -0,0 +1,6 @@
+import { Competition } from "./model/competition";
+export interface Format {
+    check(content: string): boolean;
+    parse(content: string, options: any): Competition;
+    serialize(competition: Competition): string;
+}

package/lib/format.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/formats/index.d.ts

@@ -0,0 +1,4 @@
+import * as kraemer from './kraemer';
+import * as oware from './oware';
+import * as solv from './solv';
+export { kraemer, oware, solv };

package/lib/formats/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solv = exports.oware = exports.kraemer = void 0;
+var kraemer = require("./kraemer");
+exports.kraemer = kraemer;
+var oware = require("./oware");
+exports.oware = oware;
+var solv = require("./solv");
+exports.solv = solv;

package/lib/formats/kraemer.d.ts

@@ -0,0 +1,14 @@
+import { Format } from "../format";
+import { Category } from "../model/category";
+import { Competition } from "../model/competition";
+export declare class KraemerFormater implements Format {
+    parse(text: string, options?: any): {
+        name: any;
+        map: any;
+        date: any;
+        startTime: any;
+        categories: Category[];
+    };
+    check(text: string): boolean;
+    serialize(competition: Competition): string;
+}

package/lib/formats/kraemer.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KraemerFormater = void 0;
+var time_1 = require("../time");
+function strip(str) {
+    if (!str) {
+        return "";
+    }
+    else if (str.length > 0 && str[0] === '"') {
+        return str.substring(1, str.length - 1);
+    }
+    else {
+        return str;
+    }
+}
+var KraemerFormater = /** @class */ (function () {
+    function KraemerFormater() {
+    }
+    // OE0014;Stnr;XStnr;Chipnr;Datenbank Id;Nachname;Vorname;Jg;G;Block; AK;	Start;Ziel;	 Zeit;		Wertung;Gutschrift -;Zuschlag +;Kommentar;Club-Nr.;Abk; Ort; Nat; Sitz;Region;Katnr;Kurz; Lang;		 MeldeKat. Nr;MeldeKat. (kurz);MeldeKat. (lang);Rang;Ranglistenpunkte;Num1;Num2; Num3;		 Text1;	 Text2;		Text3;	Adr. Nachname;Adr. Vorname;Straße;Zeile2;PLZ;				Adr. Ort;Tel;				 Mobil;			Fax;		EMail;	 Gemietet;Startgeld;Bezahlt;Mannschaft;Bahnnummer;Bahn;	 km;		 Hm;			Bahn Posten;Platz;	 Startstempel;Zielstempel;Posten1;Stempel1;Posten2;Stempel2;Posten3; Stempel3;Posten4;Stempel4;Posten5;Stempel5;Posten6;Stempel6;Posten7;Stempel7;Posten8;Stempel8;Posten9;Stempel9;Posten10;Stempel10;Posten11;Stempel11;Posten12;Stempel12;Posten13;Stempel13;Posten14;Stempel14;Posten15;Stempel15;Posten16;Stempel16;Posten17;Stempel17;Posten18;Stempel18;Posten19;Stempel19;Posten20;Stempel20;Posten21;Stempel21;Posten22;Stempel22;Posten23;Stempel23;Posten24;Stempel24;Posten25;Stempel25;Posten26;Stempel26;Posten27;Stempel27;Posten28;Stempel28;Posten29;Stempel29;Posten30;Stempel30;Posten31;Stempel31;Posten32;Stempel32;Posten33;Stempel33;Posten34;Stempel34;Posten35;Stempel35;Posten36;Stempel36;Posten37;Stempel37;Posten38;Stempel38;Posten39;Stempel39;Posten40;Stempel40;Posten41;Stempel41;Posten42;Stempel42;Posten43;Stempel43;Posten44;Stempel44;Posten45;Stempel45;Posten46;Stempel46;Posten47;Stempel47;Posten48;Stempel48;Posten49;Stempel49;Posten50;Stempel50;Posten51;Stempel51;Posten52;Stempel52;Posten53;Stempel53;Posten54;Stempel54;Posten55;Stempel55;Posten56;Stempel56;Posten57;Stempel57;Posten58;Stempel58;Posten59;Stempel59;Posten60;Stempel60;Posten61;Stempel61;Posten62;Stempel62;Posten63;Stempel63;Posten64;Stempel64;
+    // Stnr	;Chip;Datenbank Id;Nachname;Vorname;Jg;G;Block;AK;Start;Ziel;Zeit; Wertung;Club-Nr.;Abk;		Ort;				 Nat;			 Katnr;		Kurz;		Lang;Num1;Num2;Num3;Text1; Text2;Text3;Adr. Name;Straße;			Zeile2;					PLZ;						 Ort; Tel;						 Fax; EMail;Id/Verein;Gemietet;Startgeld;Bezahlt;Bahnnummer;	 Bahn;				km;		Hm;		Bahn Posten;Pl;			Startstempel;Zielstempel;Posten1;Stempel1;Posten2; Stempel2; Posten3;Stempel3;	Posten4;	Stempel4;Posten5;Stempel5;Posten6;		Stempel6;Posten7;		 Stempel7;	 Posten8;Stempel8;Posten9;Stempel9;Posten10;Stempel10;(und weitere)...
+    KraemerFormater.prototype.parse = function (text, options) {
+        if (options === void 0) { options = {}; }
+        // split text into lines
+        var lines = text.split(/\r?\n|\r|\n/g);
+        // extract header
+        var header = lines[0].split(";");
+        var firstTimeIdx;
+        // trying to get hold of correct column indices
+        var indices = {};
+        indices["Melde Id"] = header.indexOf("Melde Id");
+        indices["Nachname"] = header.indexOf("Nachname");
+        indices["Vorname"] = header.indexOf("Vorname");
+        indices["Jg"] = header.indexOf("Jg");
+        indices["G"] = header.indexOf("G");
+        indices["Datenbank Id"] = header.indexOf("Datenbank Id");
+        indices["Abk"] = header.indexOf("Abk");
+        indices["Club"] = header.indexOf("Ort");
+        indices["Ort"] = header.indexOf("Adr. Ort");
+        indices["Nat"] = header.indexOf("Nat");
+        indices["Start"] = header.indexOf("Start");
+        indices["Ziel"] = header.indexOf("Ziel");
+        indices["Zeit"] = header.indexOf("Zeit");
+        indices["Katnr"] = header.indexOf("Kurz");
+        indices["Rang"] = header.indexOf("Rang");
+        indices["Wertung"] = header.indexOf("Wertung");
+        indices["Posten"] = header.indexOf("Bahn Posten");
+        indices["km"] = header.indexOf("km");
+        indices["hm"] = header.indexOf("Hm");
+        firstTimeIdx = header.indexOf("Posten1");
+        if (header[0] === "OE0014") {
+            indices["Chip"] = header.indexOf("Chipnr");
+        }
+        else {
+            indices["Chip"] = header.indexOf("Chip");
+        }
+        lines = lines.slice(1);
+        // the result object
+        var categories = {};
+        function objectify(cols) {
+            var result = {};
+            Object.keys(indices).forEach(function (key) {
+                result[key] = cols[indices[key]];
+            });
+            return result;
+        }
+        lines.forEach(function (line) {
+            var cols = line.split(";");
+            var lineObj = objectify(cols);
+            if (lineObj["Wertung"] !== "0") {
+                return;
+            }
+            var categoryName = strip(lineObj["Katnr"]);
+            var runnerName = strip(lineObj["Nachname"]);
+            var runnerFirstname = strip(lineObj["Vorname"]);
+            var runTime = (0, time_1.parseTime)(lineObj["Zeit"]);
+            var startTime = (0, time_1.parseTime)(lineObj["Start"]);
+            var runner = {
+                id: lineObj["Melde Id"],
+                category: categoryName,
+                firstName: runnerFirstname,
+                name: runnerName,
+                fullName: [runnerFirstname, runnerName].join(" "),
+                yearOfBirth: lineObj["Jg"],
+                club: (strip(lineObj["Abk"]) + " " + strip(lineObj["Club"])).trim(),
+                city: strip(lineObj["Ort"]),
+                nation: strip(lineObj["Nat"]),
+                time: (0, time_1.formatTime)(runTime) || "",
+                startTime: (0, time_1.formatTime)(startTime) || "",
+                splits: [],
+            };
+            var category = categories[categoryName];
+            if (typeof category === "undefined") {
+                category = {
+                    name: strip(lineObj["Katnr"]),
+                    distance: parseInt(strip(lineObj["km"]), 10) * 1000,
+                    ascent: parseInt(strip(lineObj["hm"])),
+                    controls: parseInt(strip(lineObj["Posten"])),
+                    runners: [],
+                };
+                categories[category.name] = category;
+            }
+            var times = cols.slice(firstTimeIdx);
+            for (var idx = 0; idx < parseInt(lineObj["Posten"], 10) * 2; idx += 2) {
+                if (idx === times.length - 1) {
+                    continue;
+                }
+                var parsedTime = (0, time_1.parseTime)(times[idx + 1]);
+                runner.splits.push({ code: times[idx], time: (0, time_1.formatTime)(parsedTime) });
+            }
+            category.runners.push(runner);
+        });
+        return {
+            name: options.event || "Anonymous Event",
+            map: options.map || "Unknown Map",
+            date: options.date || "",
+            startTime: options.startTime || "",
+            categories: Object.keys(categories).map(function (category) {
+                return categories[category];
+            }),
+        };
+    };
+    KraemerFormater.prototype.check = function (text) {
+        return (text.substring(0, 6) === "OE0014" ||
+            text.substring(0, 23) === "Stnr;Chip;Datenbank Id;");
+    };
+    KraemerFormater.prototype.serialize = function (competition) {
+        throw new Error("format does not implement serialization");
+    };
+    return KraemerFormater;
+}());
+exports.KraemerFormater = KraemerFormater;

package/lib/formats/oware.d.ts

@@ -0,0 +1,7 @@
+import { Format } from "../format";
+import { Competition } from "../model/competition";
+export declare class OwareFormat implements Format {
+    parse(text: string): Competition;
+    serialize(event: Competition): string;
+    check(text: string): boolean;
+}

package/lib/formats/oware.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwareFormat = void 0;
+function parseCategory(row) {
+    return {
+        name: row[0],
+        distance: parseInt(row[1], 10),
+        ascent: parseInt(row[2], 10),
+        controls: parseInt(row[3], 10),
+        runners: [],
+    };
+}
+function parseRunner(row, category, id) {
+    var headerLength = 15;
+    var i;
+    var splits = [];
+    for (i = headerLength; i < row.length; i += 2) {
+        splits.push({ code: row[i], time: row[i + 1] });
+    }
+    // split cleanup - detect two following splits with identical time
+    // --> control not working properly; set 's' as split time (substitute)
+    // going from back to front to catch several not working controls
+    for (i = splits.length - 1; i > 0; i--) {
+        if (splits[i].time === splits[i - 1].time && splits[i].time !== "-") {
+            splits[i].time = "s";
+        }
+    }
+    return {
+        id: id,
+        category: category,
+        rank: row[0] ? parseInt(row[0]) : undefined,
+        firstName: row[2],
+        name: row[1],
+        fullName: [row[2], row[1]].join(" "),
+        yearOfBirth: row[3],
+        club: row[8],
+        city: row[7],
+        nation: row[9],
+        time: row[12],
+        startTime: row[13],
+        splits: splits,
+    };
+}
+var OwareFormat = /** @class */ (function () {
+    function OwareFormat() {
+    }
+    OwareFormat.prototype.parse = function (text) {
+        // split text into lines
+        var lines = text.trim().split(/[\r\n]+/);
+        // throw away first row containing headers
+        lines = lines.splice(1);
+        // second row contains information about the event
+        var header = lines[0].split(";");
+        var competition = {
+            // row starts with a double slash
+            name: header[0].substring(2, header[0].length),
+            map: header[1],
+            date: header[2],
+            startTime: header[3],
+            categories: [],
+        };
+        // throw a way the now parsed header
+        lines = lines.splice(1);
+        var category;
+        var idx = 0;
+        lines
+            .filter(function (line) { return line.trim().length > 0; })
+            .forEach(function (line) {
+            var cols = line.split(";");
+            if (cols.length === 4) {
+                category = parseCategory(cols);
+                competition.categories.push(category);
+            }
+            else {
+                category.runners.push(parseRunner(cols, category.name, ++idx));
+            }
+        });
+        return competition;
+    };
+    OwareFormat.prototype.serialize = function (event) {
+        var result = "//Format: Rank;Name;Firstname;YearOfBirth;SexMF;FedNr;Zip;Town;Club;NationIOF;StartNr;eCardNr;RunTime;StartTime;FinishTime;CtrlCode;SplitTime; ...\n";
+        result +=
+            "//" +
+                [event.name, event.map, event.date, event.startTime, ""].join(";") +
+                "\n";
+        event.categories.forEach(function (category) {
+            result +=
+                [
+                    category.name,
+                    category.distance,
+                    category.ascent,
+                    category.controls,
+                ].join(";") + "\n";
+            category.runners.forEach(function (runner) {
+                result += [
+                    runner.rank,
+                    runner.fullName,
+                    "",
+                    runner.yearOfBirth,
+                    "",
+                    "",
+                    "",
+                    runner.city,
+                    runner.club,
+                    runner.nation,
+                    "",
+                    "", // ecard
+                    runner.time,
+                    runner.startTime,
+                    "",
+                ].join(";");
+                result +=
+                    ";" +
+                        runner.splits
+                            .map(function (split) {
+                            return split.code + ";" + split.time;
+                        })
+                            .join(";") +
+                        "\n";
+            });
+        });
+        return result;
+    };
+    OwareFormat.prototype.check = function (text) {
+        return text.substring(0, 8) === "//Format";
+    };
+    return OwareFormat;
+}());
+exports.OwareFormat = OwareFormat;

package/lib/formats/solv.d.ts

@@ -0,0 +1,14 @@
+import { Format } from "../format";
+import { Category } from "../model/category";
+import { Competition } from "../model/competition";
+export declare class SolvFormat implements Format {
+    parse(text: string, options?: any): {
+        name: any;
+        map: any;
+        date: any;
+        startTime: any;
+        categories: Category[];
+    };
+    serialize(competition: Competition): string;
+    check(text: string): boolean;
+}

package/lib/formats/solv.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolvFormat = void 0;
+var time_1 = require("../time");
+function reformatTime(str) {
+    // "special" total times (like wrong or missing control)
+    if (str.indexOf(":") === -1) {
+        return str;
+    }
+    var parsed = (0, time_1.parseTime)(str);
+    return parsed ? (0, time_1.formatTime)(parsed) : undefined;
+}
+function reformatSplitTime(str) {
+    // normalize missing punch time
+    if (str === "-" || str === "-----") {
+        return "-";
+    }
+    // normalize not working control
+    if (str === "0.00") {
+        return "s";
+    }
+    var parsed = (0, time_1.parseTime)(str);
+    return parsed ? (0, time_1.formatTime)(parsed) : undefined;
+}
+// flat csv file format - every row contains full info including category
+// Kategorie;Laenge;Steigung;PoAnz;Rang;Name;Jahrgang;Ort;Club;Zeit;Startzeit;Zielzeit;Zwischenzeiten
+var SolvFormat = /** @class */ (function () {
+    function SolvFormat() {
+    }
+    SolvFormat.prototype.parse = function (text, options) {
+        if (options === void 0) { options = {}; }
+        var categories = {};
+        var lines = text.split("\n");
+        // drop header column
+        lines.splice(0, 1)[0].split(";");
+        lines.forEach(function (line, idx) {
+            var tokens = line.split(";");
+            if (tokens.length < 11) {
+                // invalid input? not enough data for runner
+                return;
+            }
+            var categoryName = tokens[0];
+            var category = categories[categoryName];
+            if (!category) {
+                category = {
+                    name: categoryName,
+                    distance: Math.round(parseFloat(tokens[1]) * 1000),
+                    ascent: parseInt(tokens[2]),
+                    controls: parseInt(tokens[3]),
+                    runners: [],
+                };
+                categories[categoryName] = category;
+            }
+            var name = tokens[5].split(" ");
+            var runner = {
+                id: idx,
+                category: categoryName,
+                rank: tokens[4] ? parseInt(tokens[4]) : undefined,
+                firstName: name[0],
+                name: name.slice(1).join(" "),
+                fullName: tokens[5],
+                yearOfBirth: tokens[6],
+                city: tokens[7],
+                club: tokens[8],
+                time: reformatTime(tokens[9]),
+                startTime: tokens[10],
+                splits: [],
+            };
+            if (tokens.length - 12 < category.controls * 2) {
+                // some crappy SOLV data...
+                console.log("fix crappy data from SOLV - not enough tokens on line for runner " +
+                    runner.fullName);
+                for (var i = tokens.length; i < category.controls * 2 + 12; i++) {
+                    if (i % 2 === 0) {
+                        tokens[i] =
+                            category.runners.length === 0
+                                ? "???"
+                                : category.runners[0].splits[(i - 12) / 2].code;
+                    }
+                    else {
+                        tokens[i] = "-";
+                    }
+                }
+            }
+            for (var i_1 = 12; i_1 < tokens.length - 1; i_1 += 2) {
+                var time = reformatSplitTime(tokens[i_1 + 1]);
+                if (runner.splits.length > 0 && time) {
+                    var prev = runner.splits[runner.splits.length - 1].time;
+                    var parsedTime = (0, time_1.parseTime)(tokens[i_1 + 1]);
+                    if (time === prev ||
+                        tokens[i_1 + 1] === "0.00" || (parsedTime && parsedTime > 180 * 60)) {
+                        // normalize valid manual punches
+                        time = "s";
+                    }
+                }
+                runner.splits.push({ code: tokens[i_1], time: time });
+            }
+            category.runners.push(runner);
+        });
+        return {
+            name: options.event || "Anonymous Event",
+            map: options.map || "Unknown Map",
+            date: options.date || "",
+            startTime: options.startTime || "",
+            categories: Object.keys(categories).map(function (category) {
+                return categories[category];
+            }),
+        };
+    };
+    SolvFormat.prototype.serialize = function (competition) {
+        var result = "Kategorie;Laenge;Steigung;PoAnz;Rang;Name;Jahrgang;Ort;Club;Zeit;Startzeit;Zielzeit;Zwischenzeiten\n";
+        competition.categories.forEach(function (category) {
+            category.runners.forEach(function (runner) {
+                var distance = category.distance
+                    ? category.distance
+                    : null;
+                var runTime = (0, time_1.parseTime)(runner.time);
+                var startTime = (0, time_1.parseTime)(runner.startTime);
+                var finishTime = runTime && startTime ? (0, time_1.formatTime)(runTime + startTime) : '';
+                result += [
+                    category.name,
+                    distance,
+                    category.ascent,
+                    category.controls,
+                    runner.rank,
+                    runner.fullName,
+                    runner.yearOfBirth,
+                    runner.city,
+                    runner.club,
+                    runner.time,
+                    runner.startTime,
+                    finishTime,
+                ].join(";");
+                result +=
+                    ";" +
+                        runner.splits
+                            .map(function (split) {
+                            return split.code + ";" + split.time;
+                        })
+                            .join(";") +
+                        "\n";
+            });
+        });
+        return result;
+    };
+    SolvFormat.prototype.check = function (text) {
+        return text.indexOf("Kategorie;Laenge;Steigung;PoAnz;Rang;") === 0;
+    };
+    return SolvFormat;
+}());
+exports.SolvFormat = SolvFormat;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import * as formats from './formats';
+import * as ranking from './utils/ranking';
+export { formats, ranking };

package/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ranking = exports.formats = void 0;
+var formats = require("./formats");
+exports.formats = formats;
+var ranking = require("./utils/ranking");
+exports.ranking = ranking;

package/lib/model/category.d.ts

@@ -0,0 +1,8 @@
+import { Runner } from "./runner";
+export interface Category {
+    name: string;
+    distance?: number;
+    ascent?: number;
+    controls: number;
+    runners: Runner[];
+}

package/lib/model/category.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/model/competition.d.ts

@@ -0,0 +1,8 @@
+import { Category } from "./category";
+export interface Competition {
+    name: string;
+    map?: string;
+    date: string;
+    startTime: string;
+    categories: Category[];
+}

package/lib/model/competition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/model/ranking.d.ts

@@ -0,0 +1,27 @@
+export interface Ranking {
+    runners: {
+        [key: string]: RunnerInfo;
+    };
+    legs: {
+        [key: string]: Leg;
+    };
+    ranking: RankingEntry[];
+}
+export interface Leg {
+    from: string;
+    to: string;
+    ranking: RankingEntry[];
+}
+export interface RankingEntry {
+    rank: number;
+    time: string;
+    runnerRef: string;
+}
+export interface RunnerInfo {
+    fullName: string;
+    club: string;
+    city: string;
+    category: string;
+    course: string[];
+    startTime: string;
+}

package/lib/model/ranking.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var sample = {
+    runners: {
+        "22": {
+            fullName: "Hans Dobeli",
+            club: "OLG Hopp Hopp",
+            city: "Witzwil",
+            category: "HB",
+            startTime: "01:33:00",
+            course: ["St", "31", "32", "33", "Zi"]
+        },
+        "23": {
+            fullName: "Fritz Berger",
+            club: "OLV Chapf",
+            city: "Langnau",
+            category: "HB",
+            startTime: "00:55:00",
+            course: ["St", "31", "32", "33", "Zi"]
+        }
+    },
+    legs: {
+        "St-31": {
+            from: "St",
+            to: "31",
+            ranking: [
+                {
+                    rank: 1,
+                    time: "02:33",
+                    runnerRef: "22"
+                },
+                {
+                    rank: 2,
+                    time: "08:02",
+                    runnerRef: "23"
+                }
+            ]
+        }
+    },
+    ranking: [
+        {
+            rank: 1,
+            runnerRef: "22",
+            time: "38:22"
+        },
+        {
+            rank: 2,
+            runnerRef: "23",
+            time: "46:44"
+        }
+    ]
+};

package/lib/model/runner.d.ts

@@ -0,0 +1,21 @@
+import { Split } from "./split";
+export interface Runner {
+    id: number;
+    category: string;
+    rank?: number;
+    name: string;
+    firstName: string;
+    fullName: string;
+    yearOfBirth?: string;
+    sex?: Sex;
+    city?: string;
+    nation?: string;
+    club?: string;
+    time?: string;
+    startTime: string;
+    splits: Split[];
+}
+export declare enum Sex {
+    male = "m",
+    female = "f"
+}

package/lib/model/runner.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sex = void 0;
+var Sex;
+(function (Sex) {
+    Sex["male"] = "m";
+    Sex["female"] = "f";
+})(Sex || (exports.Sex = Sex = {}));

package/lib/model/split.d.ts

@@ -0,0 +1,4 @@
+export interface Split {
+    code: string;
+    time: string | undefined;
+}

package/lib/model/split.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/time.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parses a time string that must satisfy the following regex:
+ *
+ * /(-)?[0-9]?[0-9]:[0-9][0-9](:[0-9][0-9])?/
+ *
+ * @param str input string
+ * @returns the number of seconds in the given input string or null if input is not parseable
+ */
+export declare function parseTime(str: string | undefined): number | undefined;
+export declare function formatTime(seconds: number | undefined): string;

package/lib/time.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTime = parseTime;
+exports.formatTime = formatTime;
+function pad(value) {
+    return value < 10 ? '0' + value : value;
+}
+;
+var regex = /(-)?[0-9]?[0-9]:[0-9][0-9](:[0-9][0-9])?/;
+/**
+ * Parses a time string that must satisfy the following regex:
+ *
+ * /(-)?[0-9]?[0-9]:[0-9][0-9](:[0-9][0-9])?/
+ *
+ * @param str input string
+ * @returns the number of seconds in the given input string or null if input is not parseable
+ */
+function parseTime(str) {
+    if (!str) {
+        return undefined;
+    }
+    else if (typeof str !== 'string') {
+        return undefined;
+    }
+    else if (!regex.test(str)) {
+        return undefined;
+    }
+    var split = str.split(":");
+    var result = NaN;
+    if (split.length === 2) {
+        var negative = split[0][0] === '-';
+        var minutes = parseInt(split[0], 10);
+        result = (negative ? -1 : 1) * (Math.abs(minutes) * 60 + parseInt(split[1], 10));
+    }
+    else if (split.length === 3) {
+        result = parseInt(split[0], 10) * 3600 + parseInt(split[1], 10) * 60 + parseInt(split[2], 10);
+    }
+    return isNaN(result) ? undefined : result;
+}
+function formatTime(seconds) {
+    if (!seconds) {
+        return undefined;
+    }
+    var sign = seconds < 0 ? '-' : '';
+    var value = Math.abs(seconds);
+    if (value >= 3600) {
+        return sign + Math.floor(value / 3600) + ":" + pad(Math.floor(value / 60) % 60) + ":" + pad(value % 60);
+    }
+    else {
+        return Math.floor(value / 60) + ":" + pad(value % 60);
+    }
+}

package/lib/utils/anonymizer.d.ts

@@ -0,0 +1,2 @@
+import { Competition } from "../model/competition";
+export declare function anonymize(competition: Competition): Competition;

package/lib/utils/anonymizer.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anonymize = anonymize;
+var runner_1 = require("../model/runner");
+var names = [
+    'Gustavson', 'Hendrikson', 'Meyer', 'Marlovic', 'Torres', 'Huber',
+    'Wüst', 'Zürcher', 'Berner', 'Rufer', 'Gutmann', 'Hübscher',
+    'Schneller', 'Widemar', 'Rohrer', 'Kunz', 'Kinzle', 'Steinle',
+    'Allemann', 'Röhrig', 'Meyer', 'Uhlmann', 'Garaio', 'Regazoni',
+    'Maudet', 'Zoja', 'Scheller', 'Beckenbauer', 'Würsten'
+];
+var firstNames = {
+    f: [
+        'Anna', 'Alia', 'Ava', 'Berta', 'Benita', 'Carla', 'Cloe',
+        'Dina', 'Daria', 'Eva', 'Esther', 'Elin', 'Franca', 'Franziska',
+        'Gaby', 'Gerta', 'Gudrun', 'Hanna', 'Isabel', 'Ilda', 'Kim', 'Kathrin',
+        'Lia', 'Lisa', 'Lena', 'Liselotte', 'Lara', 'Mia', 'Marla', 'Nele', 'Olga',
+        'Pia', 'Rahel', 'Sara', 'Simona', 'Sina', 'Siri', 'Xenia', 'Zoé'
+    ],
+    m: [
+        'Albert', 'Bruno', 'Chris', 'Dirk', 'David', 'Erwin', 'Francesco',
+        'Fritz', 'Gianni', 'Gustav', 'Hans', 'Henrik', 'Ian', 'Jan', 'Karl', 'Lars',
+        'Martin', 'Marco', 'Markus', 'Nico', 'Nino', 'Otto', 'Olav',
+        'Patric', 'Pablo', 'Quentin', 'Ralf', 'Rudolf', 'Simon', 'Steve',
+        'Thomas', 'Tim', 'Urs', 'Udo', 'Zan'
+    ]
+};
+var cities = [
+    'Aarberg', 'Bern', 'Burgdorf', 'Colombier', 'Diemerswil', 'Domdidier', 'Elm', 'Flawil', 'Fribourg',
+    'Goldiwil', 'Heimiswil', 'Hergiswil', 'Illiswil', 'Konolfingen', 'Lausanne', 'Locarno',
+    'Lugano', 'Martigny', 'Neuchatel', 'Orbe', 'Uzwil', 'Zürich'
+];
+var clubs = {
+    prefixes: ['OLG', 'OLV', 'OL', 'CA'],
+    names: ['Bernstein', 'Erdmannlistein', 'Blanc', 'Piz Balü', 'Bartli und Most', 'Aare', 'Reuss']
+};
+function random(arr) {
+    var idx = Math.floor(Math.random() * (arr.length - 1));
+    return arr[idx];
+}
+function randInt(from, to) {
+    return from + Math.round(Math.random() * (to - from));
+}
+function anonymize(competition) {
+    competition.categories.forEach(function (category) {
+        category.runners.forEach(function (runner) {
+            runner.name = random(names);
+            if (!runner.sex || runner.sex === 'f') {
+                runner.firstName = random(firstNames.f);
+                runner.sex = runner_1.Sex.female;
+            }
+            else {
+                runner.firstName = random(firstNames.m);
+                runner.sex = runner_1.Sex.male;
+            }
+            runner.fullName = runner.firstName + ' ' + runner.name;
+            runner.city = random(cities);
+            runner.club = random(clubs.prefixes) + ' ' + random(clubs.names);
+            runner.yearOfBirth = '' + randInt(1925, 2010);
+            runner.nation = 'SUI';
+        });
+    });
+    return competition;
+}
+;

package/lib/utils/ranking.d.ts

@@ -0,0 +1,71 @@
+import { Runner } from "../model/runner";
+export interface Course {
+    code: string;
+    runners: number[];
+}
+export interface RunnerLegs {
+    [key: string]: RunnerLeg;
+}
+export interface RunnerLeg {
+    runners: RunnerLegEntry[];
+    code: string;
+    idealSplit?: number;
+    fastestSplit?: number;
+    spread: [number, number];
+    weight?: number;
+}
+export interface RunnerLegEntry {
+    id: number;
+    fullName: string;
+    time: number;
+    split: number;
+    splitBehind?: number;
+    splitRank: number;
+    performanceIndex?: number;
+    overallRank?: number;
+    overallBehind?: string;
+    idealBehind?: string;
+    leg?: string;
+    position?: number;
+}
+interface RankingRunner {
+    id: number;
+    rank?: number;
+    fullName: string;
+    time?: string;
+    yearOfBirth?: string;
+    city?: string;
+    club?: string;
+    splits: RankingSplit[];
+}
+interface RankingSplit {
+    code: string;
+    legCode: string;
+    time?: number;
+    splitTime?: number;
+    overall: RankingInfo;
+    leg: SplitInfo;
+    performanceIndex: number | undefined;
+    position: number;
+    weight: number | undefined;
+}
+interface RankingInfo {
+    rank?: number;
+    behind?: number;
+    idealBehind?: number;
+}
+interface SplitInfo extends RankingInfo {
+    performanceIndex?: number;
+}
+export declare function parseRanking(runners: Runner[]): {
+    courses: Course[];
+    runners: RankingRunner[];
+    legs: {
+        code: string;
+        spread: [number, number];
+        idealSplit: number;
+        fastestSplit: number;
+        weight: number;
+    }[];
+};
+export {};

package/lib/utils/ranking.js

@@ -0,0 +1,383 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRanking = parseRanking;
+var time_1 = require("../time");
+function invalidTime(time) {
+    return time === undefined || time < 0;
+}
+function validTime(time) {
+    return !invalidTime(time);
+}
+function sum(a1, a2) {
+    return a1 + a2;
+}
+/**
+ * Assigns the following property to every valid leg of a runner.
+ *
+ * - splitBehind: how much time behind the faster runner
+ * - splitRank: rank on corresponding leg
+ * - leg: code of leg
+ *
+ * @param {RankingRunner[]} runners
+ * @param {RunnerLegs} legs
+ */
+function assignLegInfoToSplits(runners, legs) {
+    runners.forEach(function (runner) {
+        runner.splits
+            .filter(function (s) { return validTime(s.splitTime); })
+            .forEach(function (split) {
+            var leg = legs[split.legCode];
+            if (!leg) {
+                throw "leg with code " + split.leg + " not defined!";
+            }
+            split.legCode = leg.code;
+            var legRunner = leg.runners.find(function (r) { return r.id === runner.id; });
+            if (legRunner) {
+                split.leg.idealBehind = leg.idealSplit && legRunner.split - leg.idealSplit;
+                split.leg.behind = legRunner.splitBehind;
+                split.leg.rank = legRunner.splitRank;
+                split.performanceIndex = legRunner.performanceIndex;
+            }
+            split.weight = leg.weight;
+        });
+    });
+}
+function rank(runners) {
+    runners.forEach(function (runner, idx) {
+        if (idx === 0) {
+            runner.rank = 1;
+        }
+        else {
+            var prev = runners[idx - 1];
+            if (prev.time === runner.time) {
+                runner.rank = prev.rank;
+            }
+            else if ((0, time_1.parseTime)(runner.time)) {
+                runner.rank = idx + 1;
+            }
+        }
+    });
+}
+function parseRanking(runners) {
+    var courses = defineCourses(runners);
+    // prepare the result by defining the runners and their splits
+    var rankingRunners = defineRunners(runners);
+    // prepare auxiliary data about the legs needed to calculate ideal times, weights, ...
+    var legs = defineLegs(rankingRunners);
+    // calculate the ideal time [s]
+    var idealTime = Object.keys(legs)
+        .map(function (code) { return legs[code].idealSplit; })
+        .filter(function (time) { return time !== undefined; })
+        .reduce(sum);
+    console.log("ideal time: ", idealTime);
+    // each leg's weight is calculated regarding as a ratio of the ideal split time to the ideal time
+    Object.keys(legs).forEach(function (code) {
+        var leg = legs[code];
+        if (leg.idealSplit && idealTime > 0) {
+            leg.weight = leg.idealSplit / idealTime;
+        }
+    });
+    // now assing the leg information (such as idealTime, weight, ...) to the individual splits of the runners
+    assignLegInfoToSplits(rankingRunners, legs);
+    rankingRunners.forEach(function (runner) {
+        var behind = 0;
+        var weightSum = 0;
+        runner.splits.forEach(function (split) {
+            behind += split.leg.idealBehind;
+            split.overall = {
+                behind: behind
+            };
+            split.position = weightSum + split.weight;
+            if (split.weight) {
+                weightSum += split.weight;
+            }
+        });
+    });
+    // function of function calculating the time at an arbitrary position for a given runner
+    var timeFn = function (runner) {
+        return function (pos) {
+            if (pos === 0) {
+                return 0;
+            }
+            else if (isNaN(pos)) {
+                return undefined;
+            }
+            else if (pos >= 1) {
+                if (!(0, time_1.parseTime)(runner.time)) {
+                    return undefined;
+                }
+                return (0, time_1.parseTime)(runner.time);
+            }
+            var idx = 0;
+            var weightSum = 0;
+            var prevTime = 0;
+            for (idx = 0; idx < runner.splits.length; idx++) {
+                var split = runner.splits[idx];
+                if (weightSum + split.weight >= pos) {
+                    break;
+                }
+                weightSum += split.weight;
+                prevTime = split.time;
+            }
+            var prev = idx === 0 ? { position: 0, time: 0 } : runner.splits[idx - 1];
+            var next = runner.splits[idx];
+            if (prev === undefined ||
+                next === undefined ||
+                invalidTime(prev.time) ||
+                invalidTime(next.splitTime)) {
+                return undefined;
+            }
+            return prevTime + ((pos - prev.position) / next.weight) * next.splitTime;
+        };
+    };
+    // function returning the times at a given position for all runners
+    var memo = new Map();
+    var timesAtPosition = function (pos) {
+        if (memo.has(pos)) {
+            return memo.get(pos);
+        }
+        var result = rankingRunners.map(function (runner) {
+            return { id: runner.id, time: timeFn(runner)(pos) };
+        });
+        memo.set(pos, result);
+        return result;
+    };
+    rankingRunners.forEach(function (runner) {
+        runner.splits.forEach(function (split) {
+            var times = timesAtPosition(split.position)
+                .filter(function (entry) { return entry.time && entry.time > 0; })
+                .map(function (entry) {
+                return { id: entry.id, time: entry.time };
+            });
+            times.sort(function (t1, t2) { return t1.time - t2.time; });
+            if (!split.position || isNaN(split.position)) {
+                return;
+            }
+            if (!times || times.length === 0) {
+                console.log("no times at position ", split.position, split.weight, " for runner ", runner.fullName, runner.time, times.length);
+                return;
+            }
+            var rank = 1;
+            var lastTime = times[0].time;
+            for (var idx = 0; idx < times.length; idx++) {
+                var entry = times[idx];
+                if (lastTime < entry.time) {
+                    rank++;
+                }
+                if (runner.id === entry.id) {
+                    var idealSplitTime = times.slice(0, 5).reduce(function (sum, t) { return sum + t.time; }, 0) / Math.min(5, times.length);
+                    var fastestTime = times[0].time;
+                    split.overall.rank = rank;
+                    split.overall.behind = entry.time - fastestTime;
+                    split.overall.idealBehind = Math.round(entry.time - idealSplitTime);
+                    break;
+                }
+            }
+        });
+    });
+    // calculate the overall rank
+    rank(rankingRunners);
+    console.log(rankingRunners[0].fullName, rankingRunners[0].splits[rankingRunners[0].splits.length - 1]);
+    Object.values(legs).forEach(function (leg) {
+        var ideal = leg.idealSplit;
+        var min = leg.runners.filter(function (runner) { return !isNaN(runner.split) && runner.split !== undefined; }).map(function (runner) { return runner.split; }).reduce(function (min, split) { return Math.min(min, split - ideal); }, Number.MAX_VALUE);
+        var max = leg.runners.filter(function (runner) { return !isNaN(runner.split) && runner.split !== undefined; }).map(function (runner) { return runner.split; }).reduce(function (max, split) { return Math.max(max, split - ideal); }, Number.MIN_VALUE);
+        leg.spread = [min, max];
+    });
+    console.log("leg runner", legs[Object.keys(legs)[1]].runners[1]);
+    return {
+        courses: courses,
+        runners: rankingRunners,
+        legs: Object.values(legs).map(function (leg) { return ({
+            code: leg.code,
+            spread: leg.spread,
+            idealSplit: leg.idealSplit,
+            fastestSplit: leg.fastestSplit,
+            weight: leg.weight,
+        }); }),
+    };
+}
+/**
+ * Define the sources ran by the given runners. If all runner ran the same
+ * course, then only one course will be defined.
+ *
+ * @param runners the list of runners
+ * @returns the defined courses
+ */
+function defineCourses(runners) {
+    var courses = {};
+    runners.filter(function (runner) { return validTime((0, time_1.parseTime)(runner.time)); }).forEach(function (runner) {
+        var course = "St," + runner.splits.map(function (split) { return split.code; }).join(",");
+        if (!courses[course]) {
+            courses[course] = {
+                code: course,
+                runners: [runner.id],
+            };
+        }
+        else {
+            courses[course].runners.push(runner.id);
+        }
+    });
+    return Object.keys(courses).map(function (key) { return courses[key]; });
+}
+function defineRunners(runners) {
+    return runners.filter(function (runner) { return runner.splits.length > 0 && runner.splits.every(function (split) { return split.code; }); }).map(function (runner) {
+        var lastSplit = defineRunnerLegSplit({ code: "Zi", time: runner.time }, runner.splits.length, runner);
+        return {
+            id: runner.id,
+            rank: undefined,
+            fullName: runner.fullName,
+            time: runner.time,
+            yearOfBirth: runner.yearOfBirth,
+            city: runner.city,
+            club: runner.club,
+            splits: runner.splits.map(function (split, idx) { return defineRunnerLegSplit(split, idx, runner); }).concat([lastSplit]),
+        };
+    });
+}
+function defineRunnerLegSplit(split, idx, runner) {
+    var splitTime = undefined;
+    if (split.time === "-") {
+        splitTime = undefined;
+    }
+    else if (idx === 0) {
+        splitTime = (0, time_1.parseTime)(split.time) ? (0, time_1.parseTime)(split.time) : undefined;
+    }
+    else {
+        var current = (0, time_1.parseTime)(split.time);
+        var previous = (0, time_1.parseTime)(runner.splits[idx - 1].time);
+        if (!current || !previous) {
+            splitTime = undefined;
+        }
+        else {
+            splitTime = current - previous;
+        }
+    }
+    return {
+        code: split.code,
+        legCode: legCode(runner.splits, idx),
+        time: (0, time_1.parseTime)(split.time),
+        splitTime: splitTime,
+        leg: {
+            rank: undefined,
+            behind: 0,
+            idealBehind: undefined
+        },
+        overall: {
+            rank: undefined,
+            behind: 0,
+            idealBehind: undefined
+        },
+        performanceIndex: undefined,
+        position: 0,
+        weight: undefined
+    };
+}
+function legCode(splits, idx) {
+    if (idx === 0) {
+        return "St-" + splits[0].code;
+    }
+    else if (idx === splits.length) {
+        return splits[idx - 1].code + "-Zi";
+    }
+    else {
+        return splits[idx - 1].code + "-" + splits[idx].code;
+    }
+}
+function defineLegs(runners) {
+    var legs = Array.from(runners
+        .map(function (runner) {
+        return runner.splits.map(function (split, idx) {
+            var from = idx === 0 ? "St" : runner.splits[idx - 1].code;
+            var to = split.code;
+            var code = from + "-" + to;
+            return code;
+        });
+    }).reduce(function (a, b) { return a.concat(b); }, [])
+        .reduce(function (a, b) { return a.add(b); }, new Set())).reduce(function (obj, code) {
+        obj[code] = {
+            code: code,
+            runners: [],
+            spread: [0, 0],
+        };
+        return obj;
+    }, {});
+    runners.forEach(function (runner) {
+        runner.splits
+            //.filter((s) => validTime(s.time))
+            .forEach(function (split, idx) {
+            var from = idx === 0 ? "St" : runner.splits[idx - 1].code;
+            var to = split.code;
+            var code = from + "-" + to;
+            var current = legs[code];
+            if (validTime(split.time)) {
+                current.runners.push({
+                    id: runner.id,
+                    fullName: runner.fullName,
+                    splitRank: 0,
+                    time: split.time,
+                    split: idx === 0
+                        ? split.time
+                        : split.time - runner.splits[idx - 1].time,
+                });
+            }
+        });
+    });
+    defineLegProperties(legs);
+    return legs;
+}
+/**
+ * Define properties of each leg. After this method the leg structure will be enhanced as follows:
+ *
+ * - runners are sorted per split time per leg
+ * - each leg has a property 'idealSplit' (ideal split time of this leg)
+ * - each leg has a property 'fastestSplit'
+ * - each runner entry of a leg is enhanced with 'splitBehind' and 'splitRank'
+ *
+ * @param {*} legs leg data structre (only split is relevant)
+ */
+function defineLegProperties(legs) {
+    Object.keys(legs).forEach(function (code) {
+        var leg = legs[code];
+        leg.runners.sort(function (r1, r2) {
+            return r1.split - r2.split;
+        });
+        // calculate the ideal time: take up to 5 fastest on that leg
+        var selected = leg.runners
+            .slice(0, Math.min(leg.runners.length, 5))
+            .map(function (runner) { return runner.split; });
+        // only if there are valid splits for this leg
+        if (selected.length > 0) {
+            leg.idealSplit = Math.round(selected.reduce(sum) / selected.length);
+            if (leg.idealSplit < 0) {
+                throw new Error("invalid ideal split calculated for leg " + code);
+            }
+        }
+        // only if there are valid splits for this leg
+        if (leg.runners.length > 0) {
+            var fastestSplit_1 = leg.runners[0].split;
+            leg.fastestSplit = fastestSplit_1;
+            leg.runners[0].splitBehind = 0;
+            leg.runners.slice(1).forEach(function (runner) {
+                runner.splitBehind = runner.split - fastestSplit_1;
+            });
+            leg.runners[0].splitRank = 1;
+            leg.runners.forEach(function (runner, idx, arr) {
+                if (idx > 0) {
+                    if (runner.split === arr[idx - 1].split) {
+                        runner.splitRank = arr[idx - 1].splitRank;
+                    }
+                    else {
+                        runner.splitRank = idx + 1;
+                    }
+                }
+                if (leg.idealSplit) {
+                    runner.performanceIndex = Math.round(((1.0 * leg.idealSplit) / runner.split) * 100);
+                }
+                else {
+                    console.log("cannot calculate performance index for runner ", runner.fullName, " on leg ", code);
+                }
+            });
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rasifix/orienteering-utils",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "utility functions for orienteering result analyzis",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -28,8 +28,8 @@
   "devDependencies": {
     "@types/chai": "^5.2.3",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^16.0.2",
+    "@types/node": "^22.10.5",
     "ts-node": "^10.9.2",
-    "typescript": "^4.5.5"
+    "typescript": "^5.7.3"
   }
 }

package/lib/analyzis.js

@@ -1,25 +0,0 @@
-const { parseTime, formatTime } = require('./time');
-
-export function errorTime(runner, options) {
-  let thresholdRelative = options.thresholdRelative || 1.2;
-  let thresholdAbsolute = options.thresholdAbsolute || 10;
-
-  let perfindices = runner.splits.filter(perfidx => perfidx).map(split => split.perfidx).sort((s1, s2) => s1 - s2 );
-  let middle = null;
-  if (perfindices.length % 2 === 1) {
-    middle = perfindices[Math.floor(perfindices.length / 2)];
-  } else {
-    middle = (perfindices[perfindices.length / 2] + perfindices[perfindices.length / 2 + 1]) / 2;
-  }
-  
-  let errorTime = 0;
-  runner.splits.filter(split => split.split !== '-' && split.split !== 's').forEach(split => {
-    let errorFreeTime = Math.round(parseTime(split.split) * (split.perfidx / middle));
-    if (parseTime(split.split) / errorFreeTime > thresholdRelative && (parseTime(split.split) - errorFreeTime) > thresholdAbsolute) {        
-      split.timeLoss = formatTime(parseTime(split.split) - errorFreeTime);
-      errorTime += parseTime(split.timeLoss);
-    }
-  });
-
-  return formatTime(errorTime);
-}