chore: add biome for linting/formatting + CI action for linting in SRC folder (#1284)

* chore: add npm + vite for progressive enhancement

* fix: update Dockerfile to copy only the dist folder contents

* fix: update Dockerfile to use multi-stage build for optimized production image

* fix: correct nginx config file copy command in Dockerfile

* chore: add netlify configuration for build and redirects

* fix: add NODE_VERSION to environment in Netlify configuration

* remove wrong dist folder

* Update package.json

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* chore: split public and src

* migrating all util files from js to ts

* feat: Implement HeightmapGenerator and Voronoi module

- Added HeightmapGenerator class for generating heightmaps with various tools (Hill, Pit, Range, Trough, Strait, etc.).
- Introduced Voronoi class for creating Voronoi diagrams using Delaunator.
- Updated index.html to include new modules.
- Created index.ts to manage module imports.
- Enhanced arrayUtils and graphUtils with type definitions and improved functionality.
- Added utility functions for generating grids and calculating Voronoi cells.

* chore: add GitHub Actions workflow for deploying to GitHub Pages

* fix: update branch name in GitHub Actions workflow from 'main' to 'master'

* chore: update package.json to specify Node.js engine version and remove unused launch.json

* Initial plan

* Update copilot guidelines to reflect NPM/Vite/TypeScript migration

Co-authored-by: Azgaar <26469650+Azgaar@users.noreply.github.com>

* Update src/modules/heightmap-generator.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update src/utils/graphUtils.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update src/modules/heightmap-generator.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* feat: Add TIME and ERROR variables to global scope in HeightmapGenerator

* fix: Update base path in vite.config.ts for Netlify deployment

* refactor: Migrate features to a new module and remove legacy script reference

* refactor: Update feature interfaces and improve type safety in FeatureModule

* refactor: Add documentation for markupPack and defineGroups methods in FeatureModule

* refactor: Remove legacy ocean-layers.js and migrate functionality to ocean-layers.ts

* refactor: Remove river-generator.js script reference and migrate river generation logic to river-generator.ts

* refactor: Remove river-generator.js reference and add biomes module

* refactor: Migrate lakes functionality to lakes.ts and update related interfaces

* refactor: clean up global variable declarations and improve type definitions

* refactor: update shoreline calculation and improve type imports in PackedGraph

* fix: e2e tests

* chore: add biome for linting/formatting

* chore: add linting workflow using Biome

* refactor: improve code readability by standardizing string quotes and simplifying function calls

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Azgaar <maxganiev@yandex.com>
Co-authored-by: Azgaar <azgaar.fmg@yandex.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Azgaar <26469650+Azgaar@users.noreply.github.com>

src/utils/languageUtils.ts

@@ -9,7 +9,7 @@ import { P } from "./probabilityUtils";
 export const isVowel = (c: string): boolean => {
   const VOWELS = `aeiouyɑ'əøɛœæɶɒɨɪɔɐʊɤɯаоиеёэыуюяàèìòùỳẁȁȅȉȍȕáéíóúýẃőűâêîôûŷŵäëïöüÿẅãẽĩõũỹąęįǫųāēīōūȳăĕĭŏŭǎěǐǒǔȧėȯẏẇạẹịọụỵẉḛḭṵṳ`;
   return VOWELS.includes(c);
-}
+};
 
 /**
  * Remove trailing vowels from a string until it reaches a minimum length.
@@ -22,8 +22,7 @@ export const trimVowels = (string: string, minLength: number = 3) => {
     string = string.slice(0, -1);
   }
   return string;
-}
-
+};
 
 /**
  * Get adjective form of a noun based on predefined rules.
@@ -35,131 +34,133 @@ export const getAdjective = (nounToBeAdjective: string) => {
     {
       name: "guo",
       probability: 1,
-      condition: new RegExp(" Guo$"),
-      action: (noun: string) => noun.slice(0, -4)
+      condition: / Guo$/,
+      action: (noun: string) => noun.slice(0, -4),
     },
     {
       name: "orszag",
       probability: 1,
-      condition: new RegExp("orszag$"),
-      action: (noun: string) => (noun.length < 9 ? noun + "ian" : noun.slice(0, -6))
+      condition: /orszag$/,
+      action: (noun: string) =>
+        noun.length < 9 ? `${noun}ian` : noun.slice(0, -6),
     },
     {
       name: "stan",
       probability: 1,
-      condition: new RegExp("stan$"),
-      action: (noun: string) => (noun.length < 9 ? noun + "i" : trimVowels(noun.slice(0, -4)))
+      condition: /stan$/,
+      action: (noun: string) =>
+        noun.length < 9 ? `${noun}i` : trimVowels(noun.slice(0, -4)),
     },
     {
       name: "land",
       probability: 1,
-      condition: new RegExp("land$"),
+      condition: /land$/,
       action: (noun: string) => {
         if (noun.length > 9) return noun.slice(0, -4);
         const root = trimVowels(noun.slice(0, -4), 0);
-        if (root.length < 3) return noun + "ic";
-        if (root.length < 4) return root + "lish";
-        return root + "ish";
-      }
+        if (root.length < 3) return `${noun}ic`;
+        if (root.length < 4) return `${root}lish`;
+        return `${root}ish`;
+      },
     },
     {
       name: "que",
       probability: 1,
-      condition: new RegExp("que$"),
-      action: (noun: string) => noun.replace(/que$/, "can")
+      condition: /que$/,
+      action: (noun: string) => noun.replace(/que$/, "can"),
     },
     {
       name: "a",
       probability: 1,
-      condition: new RegExp("a$"),
-      action: (noun: string) => noun + "n"
+      condition: /a$/,
+      action: (noun: string) => `${noun}n`,
     },
     {
       name: "o",
       probability: 1,
-      condition: new RegExp("o$"),
-      action: (noun: string) => noun.replace(/o$/, "an")
+      condition: /o$/,
+      action: (noun: string) => noun.replace(/o$/, "an"),
     },
     {
       name: "u",
       probability: 1,
-      condition: new RegExp("u$"),
-      action: (noun: string) => noun + "an"
+      condition: /u$/,
+      action: (noun: string) => `${noun}an`,
     },
     {
       name: "i",
       probability: 1,
-      condition: new RegExp("i$"),
-      action: (noun: string) => noun + "an"
+      condition: /i$/,
+      action: (noun: string) => `${noun}an`,
     },
     {
       name: "e",
       probability: 1,
-      condition: new RegExp("e$"),
-      action: (noun: string) => noun + "an"
+      condition: /e$/,
+      action: (noun: string) => `${noun}an`,
     },
     {
       name: "ay",
       probability: 1,
-      condition: new RegExp("ay$"),
-      action: (noun: string) => noun + "an"
+      condition: /ay$/,
+      action: (noun: string) => `${noun}an`,
     },
     {
       name: "os",
       probability: 1,
-      condition: new RegExp("os$"),
+      condition: /os$/,
       action: (noun: string) => {
         const root = trimVowels(noun.slice(0, -2), 0);
         if (root.length < 4) return noun.slice(0, -1);
-        return root + "ian";
-      }
+        return `${root}ian`;
+      },
     },
     {
       name: "es",
       probability: 1,
-      condition: new RegExp("es$"),
+      condition: /es$/,
       action: (noun: string) => {
         const root = trimVowels(noun.slice(0, -2), 0);
         if (root.length > 7) return noun.slice(0, -1);
-        return root + "ian";
-      }
+        return `${root}ian`;
+      },
     },
     {
       name: "l",
       probability: 0.8,
-      condition: new RegExp("l$"),
-      action: (noun: string) => noun + "ese"
+      condition: /l$/,
+      action: (noun: string) => `${noun}ese`,
     },
     {
       name: "n",
       probability: 0.8,
-      condition: new RegExp("n$"),
-      action: (noun: string) => noun + "ese"
+      condition: /n$/,
+      action: (noun: string) => `${noun}ese`,
     },
     {
       name: "ad",
       probability: 0.8,
-      condition: new RegExp("ad$"),
-      action: (noun: string) => noun + "ian"
+      condition: /ad$/,
+      action: (noun: string) => `${noun}ian`,
     },
     {
       name: "an",
       probability: 0.8,
-      condition: new RegExp("an$"),
-      action: (noun: string) => noun + "ian"
+      condition: /an$/,
+      action: (noun: string) => `${noun}ian`,
     },
     {
       name: "ish",
       probability: 0.25,
-      condition: new RegExp("^[a-zA-Z]{6}$"),
-      action: (noun: string) => trimVowels(noun.slice(0, -1)) + "ish"
+      condition: /^[a-zA-Z]{6}$/,
+      action: (noun: string) => `${trimVowels(noun.slice(0, -1))}ish`,
     },
     {
       name: "an",
       probability: 0.5,
-      condition: new RegExp("^[a-zA-Z]{0,7}$"),
-      action: (noun: string) => trimVowels(noun) + "an"
-    }
+      condition: /^[a-zA-Z]{0,7}$/,
+      action: (noun: string) => `${trimVowels(noun)}an`,
+    },
   ];
   for (const rule of adjectivizationRules) {
     if (P(rule.probability) && rule.condition.test(nounToBeAdjective)) {
@@ -167,14 +168,15 @@ export const getAdjective = (nounToBeAdjective: string) => {
     }
   }
   return nounToBeAdjective; // no rule applied, return noun as is
-}
+};
 
 /**
  * Get the ordinal suffix for a given number.
  * @param n - The number.
  * @returns The number with its ordinal suffix.
  */
-export const nth = (n: number) => n + (["st", "nd", "rd"][((((n + 90) % 100) - 10) % 10) - 1] || "th");
+export const nth = (n: number) =>
+  n + (["st", "nd", "rd"][((((n + 90) % 100) - 10) % 10) - 1] || "th");
 
 /**
  * Generate an abbreviation for a given name, avoiding restricted codes.
@@ -187,12 +189,13 @@ export const abbreviate = (name: string, restricted: string[] = []) => {
   const words = parsed.split(" ");
   const letters = words.join("");
 
-  let code = words.length === 2 ? words[0][0] + words[1][0] : letters.slice(0, 2);
+  let code =
+    words.length === 2 ? words[0][0] + words[1][0] : letters.slice(0, 2);
   for (let i = 1; i < letters.length - 1 && restricted.includes(code); i++) {
     code = letters[0] + letters[i].toUpperCase();
   }
   return code;
-}
+};
 
 /**
  * Format a list of strings into a human-readable list.
@@ -201,9 +204,12 @@ export const abbreviate = (name: string, restricted: string[] = []) => {
  */
 export const list = (array: string[]) => {
   if (!Intl.ListFormat) return array.join(", ");
-  const conjunction = new Intl.ListFormat(document.documentElement.lang || "en", {style: "long", type: "conjunction"});
+  const conjunction = new Intl.ListFormat(
+    document.documentElement.lang || "en",
+    { style: "long", type: "conjunction" },
+  );
   return conjunction.format(array);
-}
+};
 
 declare global {
   interface Window {
@@ -214,4 +220,4 @@ declare global {
     abbreviate: typeof abbreviate;
     list: typeof list;
   }
-}
+}