Score Calculation

components/viewer/ViewScoreStatus.vue

@@ -1,12 +1,12 @@
 <template>
   <div class="d-flex gap-1" :class="{ 'flex-column': vertical }">
     <span
-      v-for="score in activeScores"
+      v-for="{ score, value } in activeScores"
       :key="score.id"
       class="d-flex flex-row gap-2"
     >
       <span v-if="score.beforeText">{{ score.beforeText }}</span>
-      <span>{{ score.startingSum }}</span>
+      <span>{{ value }}</span>
       <span v-if="score.afterText">{{ score.afterText }}</span>
     </span>
   </div>
@@ -23,16 +23,18 @@ const { vertical } = defineProps<{
   vertical?: boolean;
 }>();
 
-const { selected, pointTypes } = useProjectRefs();
+const { selected, pointTypes, points } = useProjectRefs();
 
-const activeScores = computed<PointType[]>(() => {
+const activeScores = computed<{ score: PointType; value: number }[]>(() => {
   const scores: PointType[] = pointTypes.value;
 
-  return R.filter(
-    (score: PointType) =>
-      R.isEmpty(score.activatedId) ||
-      R.includes(score.activatedId, selected.value),
-    scores,
-  );
+  return R.pipe(
+    R.filter(
+      (score: PointType) =>
+        R.isEmpty(score.activatedId) ||
+        R.includes(score.activatedId, selected.value),
+    ),
+    R.map((score) => ({ score, value: points.value[score.id] ?? 0 })),
+  )(scores);
 });
 </script>

composables/store/project.ts

@@ -2,12 +2,14 @@ import { defineStore, storeToRefs } from 'pinia';
 import * as R from 'ramda';
 import { ComputedRef, computed } from 'vue';
 
+import { buildConditions } from '~/composables/conditions';
 import {
   PointType,
   Project,
   ProjectFile,
   ProjectObj,
   ProjectRow,
+  Score,
 } from '~/composables/project';
 
 export const useProjectStore = defineStore('project', () => {
@@ -83,12 +85,46 @@ export const useProjectStore = defineStore('project', () => {
     }
   };
 
+  const points = computed<Record<string, number>>(() => {
+    const _selected = selected.value;
+
+    const startingSums: Record<string, number> = R.pipe(
+      R.map(({ id, startingSum }: PointType): [string, number] => [
+        id,
+        startingSum,
+      ]),
+      R.fromPairs,
+    )(pointTypes.value);
+
+    return R.pipe(
+      R.map((id: string) => getObject.value(id)),
+      R.chain(({ scores }: ProjectObj) => {
+        return R.pipe(
+          R.filter((score: Score) => {
+            const cond = buildConditions(score);
+            return cond(_selected);
+          }),
+          R.map(({ id, value }: Score): [string, number] => [
+            id,
+            -Number.parseInt(value),
+          ]),
+        )(scores);
+      }),
+      R.reduceBy(
+        (acc, [_, value]) => acc + value,
+        0,
+        ([id, _]) => id,
+      ),
+    )(_selected);
+  });
+
   return {
     project,
     projectRows,
     backpack,
-    selected,
     pointTypes,
+    selected,
+    points,
     isLoaded,
     loadProject,
     unloadProject,