Removed ALL errors

src/routes/tools/+page.svelte

@@ -1,7 +1,7 @@
 <script>
     import A4 from "../zhen/notes/physics/sharedComps/A4.svelte";
     import ToolButton from "./comps/ToolButton.svelte";
-    import { BatteryMedium } from 'lucide-svelte';
+    import { BatteryMedium } from '@lucide/svelte';
 </script>
 
 <div class="flex justify-center pt-10">
@@ -28,19 +28,19 @@
                         title="Sleeping battery life"
                         desc="Calculates the battery life depending on sleep and non-sleep power usage."
                         btnText="To calculator"
-                        icon={BatteryMedium}
+                        toolIcon={BatteryMedium}
                     />
                     <!-- <ToolButton
                         title="Sleeping battery life"
                         desc="Calculates the battery life depending on sleep and non-sleep power usage."
                         btnText="To calculator"
-                        icon={BatteryMedium}
+                        toolIcon={BatteryMedium}
                     />
                     <ToolButton
                         title="Sleeping battery life"
                         desc="Calculates the battery life depending on sleep and non-sleep power usage."
                         btnText="To calculator"
-                        icon={BatteryMedium}
+                        toolIcon={BatteryMedium}
                     /> -->
                 </div>
             </div>

src/routes/tools/battery-life-calculator/+page.svelte

@@ -3,7 +3,7 @@
     import { BatteryLifeCalculator } from "./pageSrc/BatteryCalc";
     import { getMCU, type MCU_Type } from "./pageSrc/MCU_defs";
 
-    let mathMachine = new BatteryLifeCalculator();
+    // let mathMachine = new BatteryLifeCalculator();
 
     let useCustom: boolean = false;
     let selectedText: string = "";

src/routes/tools/battery-life-calculator/pageSrc/BatteryCalc.js

@@ -1,108 +0,0 @@
-export class BatteryLifeCalculator {
-  constructor(
-    timeRunSeconds,
-    timeSleepSeconds,
-    consumptionActiveMilliAmpHours,
-    consumptionSleepMilliAmpHours,
-    powerBatteryTotalMilliAmpHours,
-    powerBatteryBufferBeforeEmptyPercent = 20) {
-    this.timeRunSeconds = timeRunSeconds
-    this.timeSleepSeconds = timeSleepSeconds
-    this.consumptionActiveMilliAmpHours = consumptionActiveMilliAmpHours
-    this.consumptionSleepMilliAmpHours = consumptionSleepMilliAmpHours
-    this.powerBatteryTotalMilliAmpHours = powerBatteryTotalMilliAmpHours
-    this.powerBatteryBufferBeforeEmptyPercent = powerBatteryBufferBeforeEmptyPercent
-
-    console.log("The source of this battery calc is here: https://github.com/simonneutert/batterylife-calculator\nI was too lazy to make the math myself.");
-  }
-
-  // public API
-
-  milliAmpToMicroAmp(milliAmps) {
-    return milliAmps * 1000
-  }
-
-  microAmpToMilliAmp(milliAmps) {
-    return milliAmps * 0.001
-  }
-
-  calculate() {
-    return {
-      powerAveragePerHour: this.powerEstimatedHourly(),
-      runtimeHoursEstimated: this.runtimeHoursEstimated(),
-      runtimeDaysEstimated: this.runtimeDaysEstimated(),
-      runtimeDaysRemainingHoursEstimated: this.runtimeDaysRemainingHoursEstimated()
-    }
-  }
-
-  powerEstimatedHourly() {
-    return this.calcPowerEst(
-      this.powerRun(),
-      this.consumptionActiveMilliAmpHours,
-      this.powerSleep(),
-      this.consumptionSleepMilliAmpHours
-    )
-  }
-
-  runtimeHoursEstimated() {
-    return parseInt(this.powerLipo() / this.powerEstimatedHourly())
-  }
-
-  runtimeDaysEstimated() {
-    return parseInt(this.runtimeHoursEstimated() / 24)
-  }
-
-  runtimeDaysRemainingHoursEstimated() {
-    return parseInt(this.runtimeHoursEstimated() % 24)
-  }
-
-  // private
-
-  roundOff(x) {
-    return Math.round(x * 100.0) / 100.0
-  }
-
-  calcPowerLipo(x, y) {
-    return parseFloat((x * (100 - y)) / 100)
-  }
-
-  calcRuns(x, y) {
-    return parseFloat(60 / (x + y))
-  }
-
-  calcRunsHour(x, y) {
-    return parseFloat(3600 / (x + y))
-  }
-
-  calcPowerRun(x, y) {
-    return parseFloat((x / (x + y)) * 3600)
-  }
-
-  calcPowerSleep(x, y) {
-    return parseFloat((y / (x + y)) * 3600)
-  }
-
-  powerLipo() {
-    return this.calcPowerLipo(this.powerBatteryTotalMilliAmpHours, this.powerBatteryBufferBeforeEmptyPercent)
-  }
-
-  runs() {
-    return this.calcRuns(this.timeRunSeconds, this.timeSleepSeconds)
-  }
-
-  runsHour() {
-    return this.calcRunsHour(this.timeRunSeconds, this.timeSleepSeconds)
-  }
-
-  powerRun() {
-    return this.calcPowerRun(this.timeRunSeconds, this.timeSleepSeconds)
-  }
-
-  powerSleep() {
-    return this.calcPowerSleep(this.timeRunSeconds, this.timeSleepSeconds)
-  }
-
-  calcPowerEst(a, b, c, d) {
-    return parseFloat((a / 3600) * b + (c / 3600) * d)
-  }
-}

src/routes/tools/battery-life-calculator/pageSrc/BatteryCalc.ts

@@ -0,0 +1,123 @@
+export class BatteryLifeCalculator {
+  timeRunSeconds: number;
+  timeSleepSeconds: number;
+  consumptionActiveMilliAmpHours: number;
+  consumptionSleepMilliAmpHours: number;
+  powerBatteryTotalMilliAmpHours: number;
+  powerBatteryBufferBeforeEmptyPercent: number;
+
+  constructor(
+    timeRunSeconds: number,
+    timeSleepSeconds: number,
+    consumptionActiveMilliAmpHours: number,
+    consumptionSleepMilliAmpHours: number,
+    powerBatteryTotalMilliAmpHours: number,
+    powerBatteryBufferBeforeEmptyPercent: number = 20
+  ) {
+    this.timeRunSeconds = timeRunSeconds;
+    this.timeSleepSeconds = timeSleepSeconds;
+    this.consumptionActiveMilliAmpHours = consumptionActiveMilliAmpHours;
+    this.consumptionSleepMilliAmpHours = consumptionSleepMilliAmpHours;
+    this.powerBatteryTotalMilliAmpHours = powerBatteryTotalMilliAmpHours;
+    this.powerBatteryBufferBeforeEmptyPercent = powerBatteryBufferBeforeEmptyPercent;
+
+    console.log(
+      "The source of this battery calc is here: https://github.com/simonneutert/batterylife-calculator\nI was too lazy to make the math myself."
+    );
+  }
+
+  // public API
+
+  milliAmpToMicroAmp(milliAmps: number): number {
+    return milliAmps * 1000;
+  }
+
+  microAmpToMilliAmp(milliAmps: number): number {
+    return milliAmps * 0.001;
+  }
+
+  calculate(): {
+    powerAveragePerHour: number;
+    runtimeHoursEstimated: number;
+    runtimeDaysEstimated: number;
+    runtimeDaysRemainingHoursEstimated: number;
+  } {
+    return {
+      powerAveragePerHour: this.powerEstimatedHourly(),
+      runtimeHoursEstimated: this.runtimeHoursEstimated(),
+      runtimeDaysEstimated: this.runtimeDaysEstimated(),
+      runtimeDaysRemainingHoursEstimated: this.runtimeDaysRemainingHoursEstimated(),
+    };
+  }
+
+  powerEstimatedHourly(): number {
+    return this.calcPowerEst(
+      this.powerRun(),
+      this.consumptionActiveMilliAmpHours,
+      this.powerSleep(),
+      this.consumptionSleepMilliAmpHours
+    );
+  }
+
+  runtimeHoursEstimated(): number {
+    return parseInt((this.powerLipo() / this.powerEstimatedHourly()).toString(), 10);
+  }
+
+  runtimeDaysEstimated(): number {
+    return parseInt((this.runtimeHoursEstimated() / 24).toString(), 10);
+  }
+
+  runtimeDaysRemainingHoursEstimated(): number {
+    return parseInt((this.runtimeHoursEstimated() % 24).toString(), 10);
+  }
+
+  // private methods
+
+  private roundOff(x: number): number {
+    return Math.round(x * 100.0) / 100.0;
+  }
+
+  private calcPowerLipo(x: number, y: number): number {
+    return parseFloat(((x * (100 - y)) / 100).toString());
+  }
+
+  private calcRuns(x: number, y: number): number {
+    return parseFloat((60 / (x + y)).toString());
+  }
+
+  private calcRunsHour(x: number, y: number): number {
+    return parseFloat((3600 / (x + y)).toString());
+  }
+
+  private calcPowerRun(x: number, y: number): number {
+    return parseFloat(((x / (x + y)) * 3600).toString());
+  }
+
+  private calcPowerSleep(x: number, y: number): number {
+    return parseFloat(((y / (x + y)) * 3600).toString());
+  }
+
+  powerLipo(): number {
+    return this.calcPowerLipo(this.powerBatteryTotalMilliAmpHours, this.powerBatteryBufferBeforeEmptyPercent);
+  }
+
+  runs(): number {
+    return this.calcRuns(this.timeRunSeconds, this.timeSleepSeconds);
+  }
+
+  runsHour(): number {
+    return this.calcRunsHour(this.timeRunSeconds, this.timeSleepSeconds);
+  }
+
+  powerRun(): number {
+    return this.calcPowerRun(this.timeRunSeconds, this.timeSleepSeconds);
+  }
+
+  powerSleep(): number {
+    return this.calcPowerSleep(this.timeRunSeconds, this.timeSleepSeconds);
+  }
+
+  private calcPowerEst(a: number, b: number, c: number, d: number): number {
+    return parseFloat(((a / 3600) * b + (c / 3600) * d).toString());
+  }
+}

src/routes/tools/comps/ToolButton.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
-    import type { SvelteComponent } from "svelte";
+    import type { Component } from 'svelte';
 
-    export let icon: typeof SvelteComponent | undefined = undefined;
+    export let toolIcon: Component | undefined = undefined;
 
     export let title: string = "Sleeping battery life";
     export let desc: string = "Calculates the battery life depending on sleep and non-sleep power usage.";
@@ -18,8 +18,8 @@
         <div class="text-sm">{desc}</div>
 
         <div class="flex pt-4">
-            {#if icon != undefined}
-            <svelte:component this={icon}/>
+            {#if toolIcon != undefined}
+            <svelte:component this={toolIcon}/>
             {/if}
             <a href="{btnHref}" class="btn ml-auto btn-primary btn-sm">{btnText}</a>
         </div>