chore: add biome for linting/formatting

src/modules/lakes.ts

@@ -1,7 +1,6 @@
-import { PackedGraphFeature } from "./features";
-import { min, mean } from "d3";
-import { byId,
-rn } from "../utils";
+import { mean, min } from "d3";
+import { byId, rn } from "../utils";
+import type { PackedGraphFeature } from "./features";
 
 declare global {
   var Lakes: LakesModule;
@@ -12,24 +11,25 @@ export class LakesModule {
 
   getHeight(feature: PackedGraphFeature) {
     const heights = pack.cells.h;
-    const minShoreHeight = min(feature.shoreline.map(cellId => heights[cellId])) || 20;
+    const minShoreHeight =
+      min(feature.shoreline.map((cellId) => heights[cellId])) || 20;
     return rn(minShoreHeight - this.LAKE_ELEVATION_DELTA, 2);
-  };
+  }
 
   defineNames() {
     pack.features.forEach((feature: PackedGraphFeature) => {
       if (feature.type !== "lake") return;
       feature.name = this.getName(feature);
     });
-  };
+  }
 
   getName(feature: PackedGraphFeature): string {
     const landCell = feature.shoreline[0];
     const culture = pack.cells.culture[landCell];
     return Names.getCulture(culture);
-  };
+  }
 
-  cleanupLakeData = function () {
+  cleanupLakeData = () => {
     for (const feature of pack.features) {
       if (feature.type !== "lake") continue;
       delete feature.river;
@@ -38,39 +38,50 @@ export class LakesModule {
       delete feature.closed;
       feature.height = rn(feature.height, 3);
 
-      const inlets = feature.inlets?.filter(r => pack.rivers.find(river => river.i === r));
+      const inlets = feature.inlets?.filter((r) =>
+        pack.rivers.find((river) => river.i === r),
+      );
       if (!inlets || !inlets.length) delete feature.inlets;
       else feature.inlets = inlets;
 
-      const outlet = feature.outlet && pack.rivers.find(river => river.i === feature.outlet);
+      const outlet =
+        feature.outlet &&
+        pack.rivers.find((river) => river.i === feature.outlet);
       if (!outlet) delete feature.outlet;
     }
   };
 
   defineClimateData(heights: number[] | Uint8Array) {
-    const {cells, features} = pack;
+    const { cells, features } = pack;
     const lakeOutCells = new Uint16Array(cells.i.length);
-    
+
     const getFlux = (lake: PackedGraphFeature) => {
-      return lake.shoreline.reduce((acc, c) => acc + grid.cells.prec[cells.g[c]], 0);
-    }
+      return lake.shoreline.reduce(
+        (acc, c) => acc + grid.cells.prec[cells.g[c]],
+        0,
+      );
+    };
 
     const getLakeTemp = (lake: PackedGraphFeature) => {
       if (lake.cells < 6) return grid.cells.temp[cells.g[lake.firstCell]];
-      return rn(mean(lake.shoreline.map(c => grid.cells.temp[cells.g[c]])) as number, 1);
-    }
+      return rn(
+        mean(lake.shoreline.map((c) => grid.cells.temp[cells.g[c]])) as number,
+        1,
+      );
+    };
 
     const getLakeEvaporation = (lake: PackedGraphFeature) => {
       const height = (lake.height - 18) ** Number(heightExponentInput.value); // height in meters
-      const evaporation = ((700 * (lake.temp + 0.006 * height)) / 50 + 75) / (80 - lake.temp); // based on Penman formula, [1-11]
+      const evaporation =
+        ((700 * (lake.temp + 0.006 * height)) / 50 + 75) / (80 - lake.temp); // based on Penman formula, [1-11]
       return rn(evaporation * lake.cells);
-    }
+    };
 
     const getLowestShoreCell = (lake: PackedGraphFeature) => {
       return lake.shoreline.sort((a, b) => heights[a] - heights[b])[0];
-    }
+    };
 
-    features.forEach(feature => {
+    features.forEach((feature) => {
       if (feature.type !== "lake") return;
       feature.flux = getFlux(feature);
       feature.temp = getLakeTemp(feature);
@@ -82,14 +93,16 @@ export class LakesModule {
     });
 
     return lakeOutCells;
-  };
+  }
 
   // check if lake can be potentially open (not in deep depression)
   detectCloseLakes(h: number[] | Uint8Array) {
-    const {cells} = pack;
-    const ELEVATION_LIMIT = +(byId("lakeElevationLimitOutput") as HTMLInputElement)?.value;
+    const { cells } = pack;
+    const ELEVATION_LIMIT = +(
+      byId("lakeElevationLimitOutput") as HTMLInputElement
+    )?.value;
 
-    pack.features.forEach(feature => {
+    pack.features.forEach((feature) => {
       if (feature.type !== "lake") return;
       delete feature.closed;
 
@@ -100,7 +113,9 @@ export class LakesModule {
       }
 
       let isDeep = true;
-      const lowestShorelineCell = feature.shoreline.sort((a, b) => h[a] - h[b])[0];
+      const lowestShorelineCell = feature.shoreline.sort(
+        (a, b) => h[a] - h[b],
+      )[0];
       const queue = [lowestShorelineCell];
       const checked = [];
       checked[lowestShorelineCell] = true;
@@ -114,7 +129,8 @@ export class LakesModule {
 
           if (h[neibCellId] < 20) {
             const nFeature = pack.features[cells.f[neibCellId]];
-            if (nFeature.type === "ocean" || feature.height > nFeature.height) isDeep = false;
+            if (nFeature.type === "ocean" || feature.height > nFeature.height)
+              isDeep = false;
           }
 
           checked[neibCellId] = true;
@@ -124,7 +140,7 @@ export class LakesModule {
 
       feature.closed = isDeep;
     });
-  };
+  }
 }
 
-window.Lakes = new LakesModule();
+window.Lakes = new LakesModule();