From a888d24bfda8066d29abad7b3a386fb352ae2e39 Mon Sep 17 00:00:00 2001
From: Dominic Ferrando <dominicf2001@gmail.com>
Date: Sat, 4 Jul 2026 17:39:14 -0400
Subject: [PATCH] Restructuring default config for standards

---
 apps/api/src/database/seed.ts                 | 11 ++---
 apps/api/src/scripts/analyze.ts               |  4 +-
 apps/api/src/services/calculator.ts           | 27 ++++++-----
 .../src/routes/(app)/calculator/+page.svelte  | 13 ++++--
 .../default-data.json}                        |  0
 .../standards/default-params.json}            |  0
 packages/calculator/src/index.ts              | 46 +++++++++----------
 packages/calculator/src/models.ts             |  6 +++
 8 files changed, 59 insertions(+), 48 deletions(-)
 rename packages/calculator/src/data/{default-standards.json => standards/default-data.json} (100%)
 rename packages/calculator/src/{default-config.json => data/standards/default-params.json} (100%)

diff --git a/apps/api/src/database/seed.ts b/apps/api/src/database/seed.ts
index 4262ba6..09b7342 100644
--- a/apps/api/src/database/seed.ts
+++ b/apps/api/src/database/seed.ts
@@ -1,6 +1,5 @@
 import {
-    DEFAULT_STANDARDS_DATA,
-    DEFAULT_STANDARDS_PARAMS,
+    DEFAULT_STANDARDS_CONFIG,
     StandardsDataSchema,
     StandardsParamsSchema,
 } from "@blade-and-brawn/calculator";
@@ -20,9 +19,9 @@ async function seedStandardsDataset(): Promise<string> {
         return existing.id;
     }
 
-    Value.Assert(StandardsDataSchema, DEFAULT_STANDARDS_DATA);
+    Value.Assert(StandardsDataSchema, DEFAULT_STANDARDS_CONFIG.data);
     const result = await db.insertInto("standards_datasets")
-        .values({ name: DEFAULT_NAME, data: DEFAULT_STANDARDS_DATA })
+        .values({ name: DEFAULT_NAME, data: DEFAULT_STANDARDS_CONFIG.data })
         .returning("id")
         .executeTakeFirstOrThrow();
     log.info({ id: result.id }, "seeded default standards dataset");
@@ -44,12 +43,12 @@ async function seedStandardsConfig(datasetId: string): Promise<void> {
         .where("is_selected", "=", true)
         .executeTakeFirst();
 
-    Value.Assert(StandardsParamsSchema, DEFAULT_STANDARDS_PARAMS);
+    Value.Assert(StandardsParamsSchema, DEFAULT_STANDARDS_CONFIG.params);
     const result = await db.insertInto("standards_configs")
         .values({
             name: DEFAULT_NAME,
             dataset_id: datasetId,
-            params: DEFAULT_STANDARDS_PARAMS,
+            params: DEFAULT_STANDARDS_CONFIG.params,
             is_selected: !hasSelected,
         })
         .returning("id")
diff --git a/apps/api/src/scripts/analyze.ts b/apps/api/src/scripts/analyze.ts
index d244725..771f591 100644
--- a/apps/api/src/scripts/analyze.ts
+++ b/apps/api/src/scripts/analyze.ts
@@ -1,6 +1,6 @@
 import {
     type Levels,
-    DEFAULT_STANDARDS_DATA,
+    DEFAULT_STANDARDS_CONFIG,
 } from "@blade-and-brawn/calculator";
 import { Activity, clamp, Gender, range } from "@blade-and-brawn/domain";
 import { levenbergMarquardt as LM } from "ml-levenberg-marquardt";
@@ -15,7 +15,7 @@ for (const activity of Object.values(Activity)) {
     }
 
     for (const gender of Object.values(Gender)) {
-        const standardsByGender = DEFAULT_STANDARDS_DATA[
+        const standardsByGender = DEFAULT_STANDARDS_CONFIG.data[
             activity
         ].standards.filter((s) => s["metrics"].gender === gender);
         const ages = [...new Set(standardsByGender.map((s) => s.metrics.age))];
diff --git a/apps/api/src/services/calculator.ts b/apps/api/src/services/calculator.ts
index f86d733..72ff756 100644
--- a/apps/api/src/services/calculator.ts
+++ b/apps/api/src/services/calculator.ts
@@ -1,11 +1,11 @@
-import { LevelCalculator, Standards, DEFAULT_STANDARDS_DATA, type StandardsParams, StandardsParamsSchema, StandardsDataSchema } from "@blade-and-brawn/calculator";
+import { LevelCalculator, Standards, DEFAULT_STANDARDS_CONFIG, type StandardsParams, StandardsParamsSchema, StandardsDataSchema, type StandardsConfig } from "@blade-and-brawn/calculator";
 import type { ActivityPerformance, Player } from "@blade-and-brawn/domain";
 import { db } from "../database/db";
 import { Value } from "@sinclair/typebox/value";
 import { log } from "../util";
 
 export class CalculatorService {
-    private Calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_DATA));
+    private Calculator = new LevelCalculator(new Standards(DEFAULT_STANDARDS_CONFIG));
     Standards: StandardsService = new StandardsService(this.Calculator);
 
     calculate(player: Player, activityPerformances: ActivityPerformance[]) {
@@ -37,11 +37,11 @@ class StandardsConfigService {
     }
 
     /** Retrieves the currently selected configuration */
-    async get(opt: { skipCache?: boolean } = {}): Promise<StandardsParams> {
-        if (!opt.skipCache) return this.Calculator.Standards.params;
+    async get(opt: { skipCache?: boolean } = {}): Promise<StandardsConfig> {
+        if (!opt.skipCache) return this.Calculator.Standards.cfg;
 
         await this.refresh();
-        return this.Calculator.Standards.params;
+        return this.Calculator.Standards.cfg;
     }
 
     async update(id: string, datasetId: string, params: StandardsParams) {
@@ -58,7 +58,7 @@ class StandardsConfigService {
 
         this.lastRefreshedAt = Date.now();
 
-        const config = await db.selectFrom("standards_configs")
+        const result = await db.selectFrom("standards_configs")
             .innerJoin("standards_datasets", "standards_datasets.id", "standards_configs.dataset_id")
             .select([
                 "standards_configs.dataset_id as datasetId",
@@ -68,15 +68,18 @@ class StandardsConfigService {
             .where("standards_configs.is_selected", "=", true)
             .limit(1)
             .executeTakeFirstOrThrow({ errorConstructor: () => new Error("No standards config selected") });
-        Value.Assert(StandardsParamsSchema, config.params);
-        Value.Assert(StandardsDataSchema, config.data);
+        Value.Assert(StandardsParamsSchema, result.params);
+        Value.Assert(StandardsDataSchema, result.data);
 
-        const parametersStringified = JSON.stringify(config.params);
-        if (parametersStringified === this.cachedParametersStringified && config.datasetId === this.cachedDatasetId) return;
+        const parametersStringified = JSON.stringify(result.params);
+        if (parametersStringified === this.cachedParametersStringified && result.datasetId === this.cachedDatasetId) return;
 
-        this.Calculator.Standards = new Standards(config.data, config.params);
+        this.Calculator.Standards = new Standards({
+            data: result.data,
+            params: result.params
+        });
         this.cachedParametersStringified = parametersStringified;
-        this.cachedDatasetId = config.datasetId;
+        this.cachedDatasetId = result.datasetId;
     }
 
     async switch(id: string) {
diff --git a/apps/portal/src/routes/(app)/calculator/+page.svelte b/apps/portal/src/routes/(app)/calculator/+page.svelte
index 6307f6d..960ff3f 100644
--- a/apps/portal/src/routes/(app)/calculator/+page.svelte
+++ b/apps/portal/src/routes/(app)/calculator/+page.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
     import {
-        DEFAULT_STANDARDS_DATA,
+        DEFAULT_STANDARDS_CONFIG,
         Standards,
         type StandardsParams,
     } from "@blade-and-brawn/calculator";
@@ -15,8 +15,6 @@
 
     let activeTab = $state("standards");
 
-    const defaultStandards = new Standards(DEFAULT_STANDARDS_DATA);
-
     let input = $state({
         activity: Activity.BenchPress,
         metrics: {
@@ -24,7 +22,9 @@
             age: null as number | null,
             weight: null as number | null, // lb
         },
-        params: structuredClone(defaultStandards.params) as StandardsParams,
+        params: structuredClone(
+            DEFAULT_STANDARDS_CONFIG.params,
+        ) as StandardsParams,
     });
 
     const selected = $derived({
@@ -38,7 +38,10 @@
     });
 
     const allStandards = $derived(
-        new Standards(DEFAULT_STANDARDS_DATA, selected.params),
+        new Standards({
+            data: DEFAULT_STANDARDS_CONFIG.data,
+            params: selected.params,
+        }),
     );
 
     $effect(() => {
diff --git a/packages/calculator/src/data/default-standards.json b/packages/calculator/src/data/standards/default-data.json
similarity index 100%
rename from packages/calculator/src/data/default-standards.json
rename to packages/calculator/src/data/standards/default-data.json
diff --git a/packages/calculator/src/default-config.json b/packages/calculator/src/data/standards/default-params.json
similarity index 100%
rename from packages/calculator/src/default-config.json
rename to packages/calculator/src/data/standards/default-params.json
diff --git a/packages/calculator/src/index.ts b/packages/calculator/src/index.ts
index f7a917c..a4e3419 100644
--- a/packages/calculator/src/index.ts
+++ b/packages/calculator/src/index.ts
@@ -10,11 +10,11 @@ import {
     type Player,
 } from "@blade-and-brawn/domain";
 import { levenbergMarquardt as LM } from "ml-levenberg-marquardt";
-import defaultConfig from "./default-config.json" with { type: "json" };
-import defaultStandardsData from "./data/default-standards.json" with { type: "json" };
+import defaultStandardsParamsJson from "./data/standards/default-params.json" with { type: "json" };
+import defaultStandardsDataJson from "./data/standards/default-data.json" with { type: "json" };
 import { getAvgWeight } from "./avg-weights";
+import { StandardsDataSchema, StandardsParamsSchema, type LevelCalculatorOutput, type Levels, type NumberMetric, type Standard, type StandardsConfig, type StandardsData } from "./models";
 import { Value } from "@sinclair/typebox/value";
-import { StandardsParamsSchema, type LevelCalculatorOutput, type Levels, type NumberMetric, type Standard, type StandardsData, type StandardsParams } from "./models";
 
 // SOURCES
 // Squat, Bench, Dead Lift:
@@ -34,8 +34,12 @@ const metricPriority = (m: NumberMetric) => {
     return 2;
 };
 
-export const DEFAULT_STANDARDS_DATA = defaultStandardsData as StandardsData;
-export const DEFAULT_STANDARDS_PARAMS = defaultConfig as StandardsParams;
+Value.Assert(StandardsDataSchema, defaultStandardsDataJson);
+Value.Assert(StandardsParamsSchema, defaultStandardsParamsJson);
+export const DEFAULT_STANDARDS_CONFIG: StandardsConfig = {
+    data: defaultStandardsDataJson,
+    params: defaultStandardsParamsJson
+};
 
 export class LevelCalculator {
     Standards: Standards;
@@ -185,15 +189,11 @@ export class LevelCalculator {
 }
 
 export class Standards {
-    readonly params: StandardsParams;
     private data: StandardsData;
 
-    constructor(data: StandardsData, params?: Partial<StandardsParams>) {
-        Value.Assert(StandardsParamsSchema, defaultConfig);
-        this.params = Object.assign({}, defaultConfig, params);
-
-        // prepare data
-        this.data = structuredClone(data);
+    constructor(readonly cfg: StandardsConfig) {
+        // prepare internal data for modification
+        this.data = structuredClone(cfg.data);
 
         // STRETCH
         for (const activity of Object.values(Activity)) {
@@ -203,7 +203,7 @@ export class Standards {
                 return (i: number) => A * Math.exp(-B * i) + C;
             }
 
-            if (!this.params.activity[activity].enableGeneration) {
+            if (!cfg.params.activity[activity].enableGeneration) {
                 continue;
             }
 
@@ -263,13 +263,13 @@ export class Standards {
                         const newLevels: Levels = {};
                         const newLowerLevelCount = Math.max(
                             Math.round(
-                                this.params.activity[activity].stretch.lower,
+                                cfg.params.activity[activity].stretch.lower,
                             ),
                             0,
                         );
                         const newUpperLevelCount = Math.max(
                             Math.round(
-                                this.params.activity[activity].stretch.upper,
+                                cfg.params.activity[activity].stretch.upper,
                             ),
                             0,
                         );
@@ -311,7 +311,7 @@ export class Standards {
                 let i = 1;
                 while (
                     Object.keys(standard.levels).length <
-                    this.params.global.maxLevel
+                    cfg.params.global.maxLevel
                 ) {
                     standard.levels = this.expandLevels(standard.levels, i++);
                 }
@@ -319,11 +319,11 @@ export class Standards {
                 // compress
                 if (
                     Object.keys(standard.levels).length >
-                    this.params.global.maxLevel
+                    cfg.params.global.maxLevel
                 ) {
                     standard.levels = this.compressLevels(
                         standard.levels,
-                        this.params.global.maxLevel,
+                        cfg.params.global.maxLevel,
                     );
                 }
 
@@ -331,12 +331,12 @@ export class Standards {
                 for (const level in standard.levels) {
                     standard.levels[level] =
                         standard.levels[level] *
-                        (1 + this.params.activity[activity].difficultyModifier);
+                        (1 + cfg.params.activity[activity].difficultyModifier);
                 }
             }
 
             // generate data
-            const allGenerators = this.params.activity[activity].enableGeneration
+            const allGenerators = cfg.params.activity[activity].enableGeneration
                 ? this.data[activity].metadata.generators.sort(
                     (a, b) =>
                         metricPriority(a.metric) - metricPriority(b.metric),
@@ -346,7 +346,7 @@ export class Standards {
             for (const generator of allGenerators) {
                 if (generator.metric === "age") {
                     for (const gender of Object.values(Gender)) {
-                        const peakAge = this.params.activity[activity].peakAge;
+                        const peakAge = cfg.params.activity[activity].peakAge;
                         const ageStep = 10;
 
                         const minAge = 0;
@@ -376,7 +376,7 @@ export class Standards {
                                 if (base == null) continue;
 
                                 const ageModifier =
-                                    this.params.activity[activity].ageModifier;
+                                    cfg.params.activity[activity].ageModifier;
 
                                 const leftSpan = peakAge - minAge;
                                 const rightSpan = maxAge - peakAge;
@@ -464,7 +464,7 @@ export class Standards {
                                         continue;
 
                                     const scalingExponent =
-                                        this.params.activity[activity]
+                                        cfg.params.activity[activity]
                                             .weightModifier;
                                     const coefficient =
                                         currWeight / referenceWeight;
diff --git a/packages/calculator/src/models.ts b/packages/calculator/src/models.ts
index a1acc1b..ad2b4d9 100644
--- a/packages/calculator/src/models.ts
+++ b/packages/calculator/src/models.ts
@@ -67,3 +67,9 @@ export const StandardsParamsSchema = t.Object({
     }))
 });
 export type StandardsParams = Static<typeof StandardsParamsSchema>;
+
+export const StandardsConfigSchema = t.Object({
+    data: StandardsDataSchema,
+    params: StandardsParamsSchema
+});
+export type StandardsConfig = Static<typeof StandardsConfigSchema>;