@rasifix/orienteering-utils 2.0.0 → 2.0.2

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/{src/time.ts → lib/time.js}

@@ -1,48 +1,52 @@
-function pad(value:number) {
+"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
  */
-export function parseTime(str:string|undefined):number|undefined {
+function parseTime(str) {
     if (!str) {
         return undefined;
-    } else if (typeof str !== 'string') {
+    }
+    else if (typeof str !== 'string') {
         return undefined;
-    } else if (!regex.test(str)) {
+    }
+    else if (!regex.test(str)) {
         return undefined;
     }
-  
     var split = str.split(":");
-    var result:number = NaN;
+    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) {
+    }
+    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;
 }
-  
-export function formatTime(seconds:number|undefined) {
+function formatTime(seconds) {
     if (!seconds) {
         return undefined;
     }
-    const sign = seconds < 0 ? '-' : '';
-    const value = Math.abs(seconds);
+    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 {
+    }
+    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/{src/utils/anonymizer.ts → lib/utils/anonymizer.js}

@@ -1,15 +1,15 @@
-import { Competition } from "../model/competition";
-import { Sex } from "../model/runner";
-
-const names = [
+"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'
 ];
-
-const firstNames = {
+var firstNames = {
     f: [
         'Anna', 'Alia', 'Ava', 'Berta', 'Benita', 'Carla', 'Cloe',
         'Dina', 'Daria', 'Eva', 'Esther', 'Elin', 'Franca', 'Franziska',
@@ -25,42 +25,35 @@ const firstNames = {
         'Thomas', 'Tim', 'Urs', 'Udo', 'Zan'
     ]
 };
-
-const cities = [
+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'
 ];
-
-const clubs = {
-    prefixes: [ 'OLG', 'OLV', 'OL', 'CA' ],
-    names: ['Bernstein', 'Erdmannlistein', 'Blanc', 'Piz Balü', 'Bartli und Most', 'Aare', 'Reuss' ]
+var clubs = {
+    prefixes: ['OLG', 'OLV', 'OL', 'CA'],
+    names: ['Bernstein', 'Erdmannlistein', 'Blanc', 'Piz Balü', 'Bartli und Most', 'Aare', 'Reuss']
 };
-
-function random(arr: string[]):string {
-    const idx = Math.floor(Math.random() * (arr.length - 1));
+function random(arr) {
+    var idx = Math.floor(Math.random() * (arr.length - 1));
     return arr[idx];
 }
-
-function randInt(from: number, to: number) {
+function randInt(from, to) {
     return from + Math.round(Math.random() * (to - from));
 }
-
-export function anonymize(competition: Competition) {
-    competition.categories.forEach(category => {
-        category.runners.forEach(runner => {
+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 = Sex.female;
-            } else {
+                runner.sex = runner_1.Sex.female;
+            }
+            else {
                 runner.firstName = random(firstNames.m);
-                runner.sex = Sex.male;
+                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);
@@ -68,4 +61,5 @@ export function anonymize(competition: Competition) {
         });
     });
     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,9 +1,13 @@
 {
   "name": "@rasifix/orienteering-utils",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "utility functions for orienteering result analyzis",
-  "main": "index",
-  "typings": "index",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
+  ],
   "scripts": {
     "test": "mocha test/test.js",
     "build": "tsc"
@@ -24,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);
-}