Simplifying and making calculation logic clearer

calculator/calc.ts

@@ -1,4 +1,4 @@
-import { Activity, Attribute, attributes, ActivityPerformance, findNearestPoints, getActivityAttribute, getAttributeActivities, Player, StandardsMap, BaseLevel, Standard } from "./util";
+import { Activity, Attribute, attributes, ActivityPerformance, findNearestPoints, getActivityAttribute, getAttributeActivities, Player, StandardsMap, Levels, Standard, Metrics, activities } from "./util";
 import rawStandards from "./standards.json" assert { type: "json" }
 
 // SOURCES
@@ -13,13 +13,30 @@ import rawStandards from "./standards.json" assert { type: "json" }
 
 const standards = rawStandards as StandardsMap;
 
-type BaseLevelValues = Record<BaseLevel, number>
+type TableData = Record<Activity, {
 
-// -------------------------------------------------------------------------------------------------
+}>
-// Level utilities (helpers)
-// -------------------------------------------------------------------------------------------------
 
-function findLevel(levels: Record<number, number>, performance: number): number {
+type LevelCalculatorConfig = {
+    compressTo?: number;
+    expandIters?: number;
+}
+
+export class LevelCalculator {
+    cfg: Required<LevelCalculatorConfig>;
+
+    public constructor(cfg: LevelCalculatorConfig = {}) {
+        this.cfg = {
+            compressTo: cfg.compressTo ?? 100,
+            expandIters: cfg.expandIters ?? 5
+        }
+    }
+
+    // -------------------------------------------------------------------------------------------------
+    // Level utilities (helpers)
+    // -------------------------------------------------------------------------------------------------
+
+    findLevel(levels: Levels, performance: number): number {
         let resultLevel = 1;
         let resultLevelDiff = Infinity;
 
@@ -31,12 +48,12 @@ function findLevel(levels: Record<number, number>, performance: number): number
             }
         }
         return resultLevel;
-}
+    }
 
-function compressLevels(
+    compressLevels(
-    levels: Record<number, number>,
+        levels: Levels,
         targetLevelsAmount: number,
-): Record<number, number> {
+    ): Levels {
         const levelsAmount = Object.keys(levels).length;
         if (levelsAmount < targetLevelsAmount) {
             throw new Error(
@@ -45,7 +62,7 @@ function compressLevels(
         }
 
         const ratio = levelsAmount / targetLevelsAmount;
-    const compressedLevels: Record<number, number> = {};
+        const compressedLevels: Levels = {};
 
         for (let i = 0; i < targetLevelsAmount; ++i) {
             const ratioIndex = i * ratio;
@@ -60,20 +77,14 @@ function compressLevels(
         }
 
         return compressedLevels;
-}
-
-function expandLevels(
-    levels: BaseLevel | Record<number, number>,
-    i: number
-): Record<number, number> {
-    if (i == 0) {
-        // ensure we always use number keys
-        const newLevels = {};
-        for (let k = 0; k < Object.keys(levels).length; ++k) {
-            newLevels[k + 1] = levels[Object.keys(levels)[k]];
     }
-        return newLevels;
+
-    };
+    expandLevels(
+        levels: Levels,
+        i: number
+    ): Levels {
+        if (i == 0)
+            return levels;
 
         const newLevels = {};
         let j = 1;
@@ -88,36 +99,34 @@ function expandLevels(
             }
         }
 
-    return expandLevels(newLevels, i - 1);
+        return this.expandLevels(newLevels, i - 1);
-}
-
-// -------------------------------------------------------------------------------------------------
-// Standards interpolation (heavy math bits)
-// -------------------------------------------------------------------------------------------------
-
-function interpolateStandardsValues(
-    lower: BaseLevelValues,
-    upper: BaseLevelValues,
-    ratio: number,
-): BaseLevelValues {
-    function lerp(k: BaseLevel): number {
-        return (lower[k] as number) + ((upper[k] as number) - (lower[k] as number)) * ratio;
     }
 
-    return {
+    // -------------------------------------------------------------------------------------------------
-        physicallyActive: lerp("physicallyActive"),
+    // Standards interpolation (heavy math bits)
-        beginner: lerp("beginner"),
+    // -------------------------------------------------------------------------------------------------
-        intermediate: lerp("intermediate"),
-        advanced: lerp("advanced"),
-        elite: lerp("elite"),
-    };
-}
 
-function interpolateByBodyWeight(
+    interpolateLevels(
+        lower: Levels,
+        upper: Levels,
+        ratio: number,
+    ): Levels {
+        if (Object.keys(lower).length !== Object.keys(upper).length)
+            throw new Error("Cannot interpolate between varying number of levels");
+
+        function lerp(lvl: number): number {
+            return (lower[lvl] as number) + ((upper[lvl] as number) - (lower[lvl] as number)) * ratio;
+        }
+
+        const interpolatedLevels = Object.keys(lower).map(lvl => lerp(+lvl));
+        return interpolatedLevels;
+    }
+
+    interpolateByBodyWeight(
         targetAge: number,
         bodyWeightKG: number,
         standardsArr: Standard[],
-): BaseLevelValues | null {
+    ): Levels | null {
         const ageFilteredStandards = standardsArr.filter((s) => s.metrics.age === targetAge);
         if (ageFilteredStandards[0].metrics.weight === -1) return ageFilteredStandards[0].levels;
 
@@ -131,57 +140,67 @@ function interpolateByBodyWeight(
         let weightRatio = upper === lower ? 1 : (bodyWeightKG - lower) / (upper - lower);
         weightRatio = Math.max(0, Math.min(1, weightRatio));
 
-    return interpolateStandardsValues(weightLower.levels, weightUpper.levels, weightRatio);
+        return this.interpolateLevels(weightLower.levels, weightUpper.levels, weightRatio);
-}
+    }
 
-function interpolateActivityLevels(
+    getInterpolatedActivityStandard(
         activity: Activity,
-    player: Player,
+        metrics: Metrics,
-): Record<number, number> {
+    ): Standard {
+        const interpolatedStandard: Standard = {
+            metrics: metrics,
+            levels: {}
+        };
+
         // Filter dataset
-    const filteredStandards = standards[activity]
+        const standardsByGender = standards[activity]
-        .filter(a => a.metrics.gender === player.gender);
+            .filter(a => a.metrics.gender === metrics.gender);
-    if (filteredStandards.length === 0) return {};
+        if (standardsByGender.length === 0) return interpolatedStandard;
 
         // Age interpolation
-    const ageArray = [...new Set(filteredStandards.map((s) => s.metrics.age))].sort((a, b) => a - b);
+        const ageArray = [...new Set(standardsByGender.map((s) => s.metrics.age))].sort((a, b) => a - b);
-    const { lower: ageLower, upper: ageUpper } = findNearestPoints(player.age, ageArray);
+        const { lower: ageLower, upper: ageUpper } = findNearestPoints(metrics.age, ageArray);
 
-    const lowerValues = interpolateByBodyWeight(ageLower, player.weightKG, filteredStandards);
+        const lowerValues = this.interpolateByBodyWeight(ageLower, metrics.weight, standardsByGender);
-    const upperValues = interpolateByBodyWeight(ageUpper, player.weightKG, filteredStandards);
+        const upperValues = this.interpolateByBodyWeight(ageUpper, metrics.weight, standardsByGender);
-    if (!lowerValues || !upperValues) return {};
+        if (!lowerValues || !upperValues) return interpolatedStandard;
 
-    let ageRatio = ageUpper === ageLower ? 1 : (player.age - ageLower) / (ageUpper - ageLower);
+        let ageRatio = ageUpper === ageLower ? 1 : (metrics.age - ageLower) / (ageUpper - ageLower);
         ageRatio = Math.max(0, Math.min(1, ageRatio));
 
-    const levels = interpolateStandardsValues(lowerValues, upperValues, ageRatio);
+        const levels = this.interpolateLevels(lowerValues, upperValues, ageRatio);
+        const expandedLevels = this.expandLevels(levels, this.cfg.expandIters);
+        const compressedLevels = this.compressLevels(expandedLevels, this.cfg.compressTo);
 
-    if (levels) {
+        interpolatedStandard.levels = compressedLevels;
-        const expandedLevels = expandLevels(levels, 5);
+        return interpolatedStandard;
-        const compressedLevels = compressLevels(expandedLevels, 100);
-        return compressedLevels;
-    } else {
-        return {};
     }
-}
 
-// -------------------------------------------------------------------------------------------------
+    // -------------------------------------------------------------------------------------------------
-// Level calculations (public API)
+    // Level calculations (public API)
-// -------------------------------------------------------------------------------------------------
+    // -------------------------------------------------------------------------------------------------
 
-export function calcAttributeLevel(
+    // public generateTableData(metrics: Metrics) {
+    //     const tableData: Record<Activity, Object> = {};
+    //
+    //     for (const activity of Object.values(activities)) {
+    //         const activityLevels = this.interpolateActivityLevels(activity, metrics);
+    //     }
+    // }
+
+    public calcAttributeLevel(
         attribute: Attribute,
         player: Player,
         activityPerformances: ActivityPerformance[],
-): number {
+    ): number {
         // must be activities of the given attribute
-    if (activityPerformances.some((bp) => getActivityAttribute(bp.activity) !== attribute)) {
+        if (activityPerformances.some((p) => getActivityAttribute(p.activity) !== attribute)) {
             throw new Error("Wrong activity performance attribute");
         }
 
         // must perform all of an attributes activities
         for (const activity of getAttributeActivities(attribute)) {
-        const filteredActivites = activityPerformances.map((bp) => bp.activity);
+            const filteredActivites = activityPerformances.map((p) => p.activity);
             if (!filteredActivites.includes(activity))
                 return 0;
         }
@@ -192,21 +211,22 @@ export function calcAttributeLevel(
                 return 0
         }
 
-    const activityLevels = activityPerformances.map((abp) =>
+        const activityLevels = activityPerformances.map((p) => {
-        findLevel(interpolateActivityLevels(abp.activity, player), abp.performance),
+            const interpolatedStandard = this.getInterpolatedActivityStandard(p.activity, player.metrics);
-    );
+            return this.findLevel(interpolatedStandard.levels, p.performance);
+        });
 
         const activityLevelsAvg = Math.round(
             activityLevels.reduce((sum, curr) => sum + curr, 0) / activityLevels.length,
         );
 
         return activityLevelsAvg;
-}
+    }
 
-export function calcAllAttributeLevels(
+    public calcAllAttributeLevels(
         player: Player,
         activityPerformances: ActivityPerformance[],
-): Record<Attribute, number> {
+    ): Record<Attribute, number> {
         const attrLevels: Record<Attribute, number> = {
             [attributes.STRENGTH]: 0,
             [attributes.POWER]: 0,
@@ -222,21 +242,21 @@ export function calcAllAttributeLevels(
 
         (Object.values(attributes) as Attribute[]).forEach((attribute) => {
             const attrActivityPerformances = activityPerformances.filter(
-            (bp) => getActivityAttribute(bp.activity) === attribute,
+                (p) => getActivityAttribute(p.activity) === attribute,
             );
-        attrLevels[attribute] = calcAttributeLevel(attribute, player, attrActivityPerformances);
+            attrLevels[attribute] = this.calcAttributeLevel(attribute, player, attrActivityPerformances);
         });
 
         return attrLevels;
-}
+    }
 
-export function calcPlayerLevel(player: Player, activityPerformances: ActivityPerformance[]): number {
+    public calcPlayerLevel(player: Player, activityPerformances: ActivityPerformance[]): number {
         for (const value of Object.values(player)) {
             if (!value)
                 return 0;
         }
 
-    const attrLevels = calcAllAttributeLevels(player, activityPerformances);
+        const attrLevels = this.calcAllAttributeLevels(player, activityPerformances);
         for (const level of Object.values(attrLevels)) {
             if (!level)
                 return 0;
@@ -244,5 +264,5 @@ export function calcPlayerLevel(player: Player, activityPerformances: ActivityPe
 
         const attrLevelsSum = Object.values(attrLevels).reduce((sum, lvl) => sum + lvl, 0);
         return Math.round(attrLevelsSum / Object.keys(attributes).length);
+    }
 }
-

calculator/test.ts

@@ -1,10 +1,12 @@
 import { activities, ActivityPerformance, feetToCm, genders, inchesToCm, lbToKg, minToMs, Player, secToMs } from "./util";
-import { calcAllAttributeLevels, calcPlayerLevel } from "./calc.ts";
+import { LevelCalculator } from "./calc.ts";
 
 const player: Player = {
+    metrics: {
         age: 18,
-    weightKG: lbToKg(200),
+        weight: lbToKg(200),
         gender: genders.MALE
+    }
 };
 
 const computedPerformances: ActivityPerformance[] = [
@@ -38,9 +40,13 @@ const computedPerformances: ActivityPerformance[] = [
     },
 ];
 
+console.log(Bun.argv);
+// const levelCalculator = new LevelCalculator({ compressTo: +Bun.argv[2], expandIters: +Bun.argv[3] });
+const levelCalculator = new LevelCalculator();
+
 const levels = {
-    attributes: calcAllAttributeLevels(player, computedPerformances),
+    attributes: levelCalculator.calcAllAttributeLevels(player, computedPerformances),
-    player: calcPlayerLevel(player, computedPerformances)
+    player: levelCalculator.calcPlayerLevel(player, computedPerformances)
 };
 
 console.log(levels);

calculator/util.ts

@@ -16,9 +16,7 @@ export type Attribute = typeof attributes[keyof typeof attributes];
 // -------------------------------------------------------------------------------------------------
 
 export interface Player {
-    age: number,
+    metrics: Metrics;
-    weightKG: number,
-    gender: Gender
 }
 
 export const activities = Object.freeze({
@@ -75,14 +73,9 @@ export interface ActivityPerformance {
     performance: number;
 }
 
-export type BaseLevel =
+export type Levels = Record<number, number>
-    | "physicallyActive"
-    | "beginner"
-    | "intermediate"
-    | "advanced"
-    | "elite";
 
-interface Metrics {
+export interface Metrics {
     age: number;
     weight: number;
     gender: Gender;
@@ -90,7 +83,7 @@ interface Metrics {
 
 export interface Standard {
     metrics: Metrics;
-    levels: Record<BaseLevel, number>;
+    levels: Levels;
 }
 
 export type StandardsMap = Record<

main.ts

@@ -1,11 +1,11 @@
-import { calcAllAttributeLevels, calcPlayerLevel } from "./calculator/calc.ts";
+import { LevelCalculator } from "./calculator/calc.ts";
 import { ActivityPerformance, Player } from "./calculator/util.ts";
 import { Printful } from "./commerce/printful.ts"
 import { Webflow } from "./commerce/webflow.ts";
 
 interface CalcRequest {
     player: Player,
-    performances: ActivityPerformance[]
+    activityPerformances: ActivityPerformance[]
 }
 
 export class ClientResponse extends Response {
@@ -34,12 +34,14 @@ const server = Bun.serve({
             },
             async POST(req) {
                 const calcReq: CalcRequest = await req.json();
-                const { player, performances } = calcReq;
+                const { player, activityPerformances } = calcReq;
+
+                const levelCalculator = new LevelCalculator();
 
                 return ClientResponse.json({
                     levels: {
-                        attributes: calcAllAttributeLevels(player, performances),
+                        attributes: levelCalculator.calcAllAttributeLevels(player, activityPerformances),
-                        player: calcPlayerLevel(player, performances)
+                        player: levelCalculator.calcPlayerLevel(player, activityPerformances)
                     }
                 })
             }
@@ -90,7 +92,8 @@ const server = Bun.serve({
                         }
                         // DELETE
                         case Printful.Webhook.Event.ProductDeleted: {
-                            await Webflow.Products.remove(payload.data.sync_product.external_id);
+                            const webflowProductId = payload.data.sync_product.external_id;
+                            await Webflow.Products.remove(webflowProductId);
                             break;
                         }
                     }