@mxfb/tools 0.0.43 → 0.2.3

package/agnostic/_WIP_tennis/index.js

@@ -0,0 +1,62 @@
+// src/agnostic/_WIP_tennis/index.ts
+var Tennis;
+((Tennis2) => {
+  function getGameScore(game) {
+    const score = [0, 0];
+    game.forEach((point) => {
+      if (score.includes(5)) return;
+      const winnerPos = point ? 0 : 1;
+      const loserPos = point ? 1 : 0;
+      const winnerCurrScore = score[winnerPos];
+      const loserCurrScore = score[loserPos];
+      if (loserCurrScore === 5 || winnerCurrScore === 5) return;
+      if (loserCurrScore === 4 && winnerCurrScore === 3) {
+        score[loserPos] = 3;
+        return;
+      }
+      if (loserCurrScore === 3 && winnerCurrScore === 4) {
+        score[winnerPos] = 5;
+        return;
+      }
+      if (winnerCurrScore === 3) {
+        score[winnerPos] = 5;
+        return;
+      }
+      score[winnerPos]++;
+      return;
+    });
+    return score;
+  }
+  function getGameWinner(gameScore) {
+    const [scoreA, scoreB] = gameScore;
+    if (scoreA === 5) return true;
+    if (scoreB === 5) return false;
+    return null;
+  }
+  function getSetScore(set) {
+    const score = [0, 0];
+    let foundUnfinishedGame = false;
+    set.forEach((game) => {
+      if (foundUnfinishedGame) return;
+      if (score.includes(7)) return;
+      const [scoreA, scoreB] = score;
+      if (scoreA >= 6 && scoreB < 5) return;
+      if (scoreB <= 6 && scoreA < 5) return;
+      const gameScore = getGameScore(game);
+      const gameWinner = getGameWinner(gameScore);
+      if (gameWinner === true) {
+        score[0]++;
+        return;
+      }
+      if (gameWinner === false) {
+        score[1]++;
+        return;
+      }
+      foundUnfinishedGame = true;
+    });
+    return score;
+  }
+})(Tennis || (Tennis = {}));
+export {
+  Tennis
+};

package/agnostic/index.d.ts

@@ -0,0 +1,4 @@
+import * as MiscNamespace from './misc';
+export declare namespace Agnostic {
+    export import Misc = MiscNamespace;
+}

package/agnostic/misc/elo/index.d.ts

@@ -0,0 +1,31 @@
+export declare namespace Elo {
+    const K_FACTOR = 32;
+    /**
+     * Calcule la probabilité de gain de A en fonction des scores Elo de A et B.
+     * @param eloA Le score Elo du joueur A.
+     * @param eloB Le score Elo du joueur B.
+     * @returns La probabilité que le joueur A gagne contre le joueur B.
+     */
+    function getWinProbability(eloA: number, eloB: number): number;
+    /**
+     * Calcule les nouveaux classements Elo pour les scénarios de victoire de A, de B et de match nul.
+     * @param eloA Le score Elo actuel du joueur A.
+     * @param eloB Le score Elo actuel du joueur B.
+     * @param kFactor Facteur K pour les calculs Elo (facultatif, valeur par défaut = 32).
+     * @returns Un objet contenant les nouveaux classements Elo pour chaque scénario de résultat.
+     */
+    function getOutcome(eloA: number, eloB: number, kFactor?: number): {
+        aWins: {
+            eloA: number;
+            eloB: number;
+        };
+        bWins: {
+            eloA: number;
+            eloB: number;
+        };
+        null: {
+            eloA: number;
+            eloB: number;
+        };
+    };
+}

package/agnostic/misc/elo/index.js

@@ -0,0 +1,6 @@
+import {
+  Elo
+} from "../../../chunks/chunk-ZC5RZBNY.js";
+export {
+  Elo
+};

package/agnostic/misc/index.d.ts

@@ -0,0 +1,6 @@
+import { Elo as EloNamespace } from './elo';
+import { Tennis as TennisNamespace } from './tennis';
+export declare namespace Misc {
+    export import Elo = EloNamespace;
+    export import Tennis = TennisNamespace;
+}

package/agnostic/misc/index.js

@@ -0,0 +1,16 @@
+import {
+  Elo
+} from "../../chunks/chunk-ZC5RZBNY.js";
+import {
+  Tennis
+} from "../../chunks/chunk-TTZHPIH7.js";
+
+// src/agnostic/misc/index.ts
+var Misc;
+((Misc2) => {
+  Misc2.Elo = Elo;
+  Misc2.Tennis = Tennis;
+})(Misc || (Misc = {}));
+export {
+  Misc
+};

package/agnostic/misc/tennis/index.d.ts

@@ -0,0 +1,60 @@
+export declare namespace Tennis {
+    namespace Score {
+        type PointDescriptor = boolean;
+        type GameFormat = {
+            upTo: number;
+            diffToWin: number;
+        };
+        class Game {
+            private format;
+            private pointsSequence;
+            constructor(format: GameFormat);
+            add(point: PointDescriptor): this;
+            getNumericScore(): [number, number];
+            static numericToStringScoreValue(numScore: [number, number]): string;
+            getScore(): string;
+            isFinished(): boolean;
+            getWinner(): boolean | null;
+        }
+        type SetFormat = {
+            upTo: number;
+            diffToWin: number;
+            gamesFormat: GameFormat;
+            tieBreakAt: number | null;
+            tieBreakFormat: GameFormat;
+        };
+        class Set {
+            private format;
+            private pointsSequence;
+            constructor(format: SetFormat);
+            add(point: PointDescriptor): void;
+            getGames(): Game[];
+            getNumericScore(): {
+                games: [number, number];
+                currentGame?: [number, number];
+            };
+            getScore(): string;
+            isFinished(): boolean;
+            getWinner(): boolean | null;
+        }
+        type MatchFormat = {
+            upTo: number;
+            setsFormat: SetFormat;
+            lastSetFormat: SetFormat;
+        };
+        class Match {
+            private format;
+            private pointsSequence;
+            constructor(format: MatchFormat);
+            add(point: PointDescriptor): void;
+            getSets(): Set[];
+            getNumericScore(): {
+                sets: [number, number][];
+                currentGame?: [number, number];
+            };
+            getScore(): string;
+            isFinished(): boolean;
+            getWinner(): boolean | null;
+        }
+    }
+}

package/agnostic/misc/tennis/index.js

@@ -0,0 +1,6 @@
+import {
+  Tennis
+} from "../../../chunks/chunk-TTZHPIH7.js";
+export {
+  Tennis
+};

package/chunks/chunk-TTZHPIH7.js

@@ -0,0 +1,237 @@
+// src/agnostic/misc/tennis/index.ts
+var Tennis;
+((Tennis2) => {
+  let Score;
+  ((Score2) => {
+    class Game {
+      format;
+      pointsSequence = [];
+      constructor(format) {
+        this.format = format;
+      }
+      add(point) {
+        if (!this.isFinished()) this.pointsSequence.push(point);
+        return this;
+      }
+      getNumericScore() {
+        const { pointsSequence, format } = this;
+        const { upTo, diffToWin } = format;
+        return pointsSequence.reduce((reduced, point) => {
+          const [aScore, bScore] = reduced;
+          const aWon = aScore >= upTo && aScore - bScore >= diffToWin;
+          const bWon = bScore >= upTo && bScore - aScore >= diffToWin;
+          if (aWon || bWon) return reduced;
+          return point ? [aScore + 1, bScore] : [aScore, bScore + 1];
+        }, [0, 0]);
+      }
+      static numericToStringScoreValue(numScore) {
+        const [aScore, bScore] = numScore;
+        if (aScore >= 3 && bScore >= 3) {
+          if (aScore === bScore) return "deuce";
+          if (aScore < bScore) return "Ad/40";
+          return "40/Ad";
+        }
+        const strScoresList = ["0", "15", "30", "40"];
+        return `${strScoresList.at(aScore) ?? "?"}/${strScoresList.at(bScore) ?? "?"}`;
+      }
+      getScore() {
+        return Game.numericToStringScoreValue(this.getNumericScore());
+      }
+      isFinished() {
+        const { format } = this;
+        const { upTo, diffToWin } = format;
+        const [aScore, bScore] = this.getNumericScore();
+        const maxScoreReached = Math.max(aScore, bScore) >= upTo;
+        const diffReached = Math.abs(aScore - bScore) >= diffToWin;
+        if (maxScoreReached && diffReached) return true;
+        return false;
+      }
+      getWinner() {
+        if (!this.isFinished()) return null;
+        const [aScore, bScore] = this.getNumericScore();
+        return aScore > bScore;
+      }
+    }
+    Score2.Game = Game;
+    class Set {
+      format;
+      pointsSequence = [];
+      constructor(format) {
+        this.format = format;
+      }
+      add(point) {
+        this.pointsSequence.push(point);
+      }
+      getGames() {
+        const { format } = this;
+        const { upTo, diffToWin, gamesFormat, tieBreakFormat, tieBreakAt } = format;
+        let aGames = 0;
+        let bGames = 0;
+        const games = [];
+        const { pointsSequence } = this;
+        pointsSequence.forEach((point) => {
+          const maxGamesReached = Math.max(aGames, bGames) >= upTo;
+          const diffReached = Math.abs(aGames - bGames) >= diffToWin;
+          if (maxGamesReached && diffReached) return;
+          const lastGameInList = games.at(-1);
+          const lastGameIsFinished = lastGameInList?.isFinished();
+          if (lastGameInList === void 0 || lastGameIsFinished === true) {
+            const isTiebreak = aGames === bGames && aGames === tieBreakAt;
+            if (isTiebreak) games.push(new Game(tieBreakFormat));
+            else games.push(new Game(gamesFormat));
+          }
+          const currentGame = games.at(-1);
+          if (currentGame === void 0) throw "Something went wrong, this should't be undefined";
+          currentGame.add(point);
+          const currentGameWinner = currentGame.getWinner();
+          if (currentGameWinner === true) {
+            aGames += 1;
+          }
+          if (currentGameWinner === false) {
+            bGames += 1;
+          }
+        });
+        return games;
+      }
+      getNumericScore() {
+        const games = this.getGames();
+        let aScore = 0;
+        let bScore = 0;
+        games.forEach((game) => {
+          const winner = game.getWinner();
+          if (winner === true) {
+            aScore++;
+          }
+          if (winner === false) {
+            bScore++;
+          }
+        });
+        const lastGame = games.at(-1);
+        if (lastGame === void 0) return { games: [aScore, bScore] };
+        if (lastGame.isFinished() === false) return {
+          games: [aScore, bScore],
+          currentGame: lastGame.getNumericScore()
+        };
+        return { games: [aScore, bScore] };
+      }
+      getScore() {
+        const numericScore = this.getNumericScore();
+        const { games, currentGame } = numericScore;
+        if (currentGame === void 0) return `${games.join("/")}`;
+        return `${games.join("/")} ${Game.numericToStringScoreValue(currentGame)}`;
+      }
+      isFinished() {
+        const { format } = this;
+        const { upTo, diffToWin, tieBreakAt } = format;
+        const [aScore, bScore] = this.getNumericScore().games;
+        const maxGamesReached = Math.max(aScore, bScore) >= upTo;
+        const diffReached = Math.abs(aScore - bScore) >= diffToWin;
+        const tieBreakBeenPlayed = tieBreakAt !== null && Math.max(aScore, bScore) > tieBreakAt;
+        return tieBreakBeenPlayed || maxGamesReached && diffReached;
+      }
+      getWinner() {
+        if (!this.isFinished()) return null;
+        const [aScore, bScore] = this.getNumericScore().games;
+        return aScore > bScore;
+      }
+    }
+    Score2.Set = Set;
+    class Match {
+      format;
+      pointsSequence = [];
+      constructor(format) {
+        this.format = format;
+      }
+      add(point) {
+        this.pointsSequence.push(point);
+      }
+      getSets() {
+        const { format } = this;
+        const { upTo, setsFormat, lastSetFormat } = format;
+        let aSets = 0;
+        let bSets = 0;
+        const sets = [];
+        const { pointsSequence } = this;
+        pointsSequence.forEach((point) => {
+          const maxSetsReached = Math.max(aSets, bSets) >= upTo;
+          if (maxSetsReached) return;
+          const lastSetInList = sets.at(-1);
+          const lastSetIsFinished = lastSetInList?.isFinished();
+          if (lastSetInList === void 0 || lastSetIsFinished === true) {
+            const isLastSet = aSets === bSets && aSets === upTo - 1;
+            if (isLastSet) sets.push(new Set(lastSetFormat));
+            else sets.push(new Set(setsFormat));
+          }
+          const currentSet = sets.at(-1);
+          if (currentSet === void 0) throw "Something went wrong, this should't be undefined";
+          currentSet.add(point);
+          const currentSetWinner = currentSet.getWinner();
+          if (currentSetWinner === true) {
+            aSets += 1;
+          }
+          if (currentSetWinner === false) {
+            bSets += 1;
+          }
+        });
+        return sets;
+      }
+      getNumericScore() {
+        const sets = this.getSets();
+        const numericScore = {
+          sets: [],
+          currentGame: void 0
+        };
+        sets.forEach((set) => {
+          const setNumericScore = set.getNumericScore();
+          const { games, currentGame } = setNumericScore;
+          numericScore.sets.push(games);
+          if (currentGame !== void 0) {
+            numericScore.currentGame = currentGame;
+          }
+        });
+        return numericScore;
+      }
+      getScore() {
+        return this.getSets().map((set) => set.getScore()).join(" ");
+      }
+      isFinished() {
+        const { format } = this;
+        const { upTo } = format;
+        const sets = this.getSets();
+        let aSets = 0;
+        let bSets = 0;
+        sets.forEach((set) => {
+          const winner = set.getWinner();
+          if (winner === true) {
+            aSets++;
+          }
+          if (winner === false) {
+            bSets++;
+          }
+        });
+        return Math.max(aSets, bSets) >= upTo;
+      }
+      getWinner() {
+        if (!this.isFinished()) return null;
+        const sets = this.getSets();
+        let aSets = 0;
+        let bSets = 0;
+        sets.forEach((set) => {
+          const winner = set.getWinner();
+          if (winner === true) {
+            aSets++;
+          }
+          if (winner === false) {
+            bSets++;
+          }
+        });
+        return aSets > bSets;
+      }
+    }
+    Score2.Match = Match;
+  })(Score = Tennis2.Score || (Tennis2.Score = {}));
+})(Tennis || (Tennis = {}));
+
+export {
+  Tennis
+};

package/chunks/chunk-ZC5RZBNY.js

@@ -0,0 +1,33 @@
+// src/agnostic/misc/elo/index.ts
+var Elo;
+((Elo2) => {
+  Elo2.K_FACTOR = 32;
+  function getWinProbability(eloA, eloB) {
+    const exponent = (eloB - eloA) / 400;
+    return 1 / (1 + Math.pow(10, exponent));
+  }
+  Elo2.getWinProbability = getWinProbability;
+  function getOutcome(eloA, eloB, kFactor = Elo2.K_FACTOR) {
+    const probA = getWinProbability(eloA, eloB);
+    const probB = 1 - probA;
+    return {
+      aWins: {
+        eloA: Math.round(eloA + kFactor * (1 - probA)),
+        eloB: Math.round(eloB + kFactor * (0 - probB))
+      },
+      bWins: {
+        eloA: Math.round(eloA + kFactor * (0 - probA)),
+        eloB: Math.round(eloB + kFactor * (1 - probB))
+      },
+      null: {
+        eloA: Math.round(eloA + kFactor * (0.5 - probA)),
+        eloB: Math.round(eloB + kFactor * (0.5 - probB))
+      }
+    };
+  }
+  Elo2.getOutcome = getOutcome;
+})(Elo || (Elo = {}));
+
+export {
+  Elo
+};

package/components/index.d.ts

@@ -0,0 +1 @@
+export declare namespace Components { }

package/node/index.d.ts

@@ -0,0 +1,2 @@
+import * as MxfbCliConfig from './mxfb-cli-config';
+export { MxfbCliConfig };

package/node/mxfb-cli-config/index.js

@@ -0,0 +1,113 @@
+// src/node/mxfb-cli-config/index.ts
+import os from "node:os";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+var homeDirPath = os.homedir();
+var mxfbConfigDirPath = path.join(homeDirPath, ".config/mxfb-cli");
+var mxfbConfigFilePath = path.join(mxfbConfigDirPath, "config.json");
+var emptyConfigObj = {};
+async function createConfigFile(force = false) {
+  await fs.mkdir(mxfbConfigDirPath, { recursive: true });
+  try {
+    await fs.stat(mxfbConfigFilePath);
+    if (force === true) throw "create anyway";
+    return true;
+  } catch (err) {
+    try {
+      await fs.writeFile(
+        mxfbConfigFilePath,
+        `${JSON.stringify(emptyConfigObj, null, 2)}
+`,
+        { encoding: "utf-8" }
+      );
+      return true;
+    } catch (err2) {
+      if (err2 instanceof Error) return err2;
+      if (typeof err2 === "string") return new Error(err2);
+      return new Error(`${err2}`);
+    }
+  }
+}
+var deletionSecurityPhrase = "THIS IS A DESTRUCTIVE AND DEFINITIVE ACTION";
+async function deleteConfigDir(security) {
+  if (security !== deletionSecurityPhrase) return new Error("You must provide the security phrase");
+  await fs.rm(mxfbConfigDirPath, { recursive: true, force: true });
+  return true;
+}
+async function deleteConfigFile(security) {
+  if (security !== deletionSecurityPhrase) return new Error("You must provide the security phrase");
+  await fs.rm(mxfbConfigDirPath);
+  return true;
+}
+async function ensureConfigFile() {
+  try {
+    await fs.stat(mxfbConfigFilePath);
+    return true;
+  } catch (err) {
+    try {
+      const created = await createConfigFile();
+      if (created instanceof Error) throw created;
+      return true;
+    } catch (err2) {
+      if (err2 instanceof Error) return err2;
+      if (typeof err2 === "string") return new Error(err2);
+      return new Error(`${err2}`);
+    }
+  }
+}
+async function getConfigFile() {
+  try {
+    const fileContents = await fs.readFile(mxfbConfigFilePath, { encoding: "utf-8" });
+    return fileContents;
+  } catch (err) {
+    if (err instanceof Error) return err;
+    if (typeof err === "string") return new Error(err);
+    return new Error(`${err}`);
+  }
+}
+function validateConfigObj(configObj) {
+  return true;
+}
+function parseConfigFile(fileContents) {
+  try {
+    const parsed = JSON.parse(fileContents);
+    const validated = validateConfigObj(parsed);
+    if (!validated) throw new Error(`Invalid config file shape: ${fileContents}`);
+    return parsed;
+  } catch (err) {
+    if (err instanceof Error) return err;
+    if (typeof err === "string") return new Error(err);
+    return new Error(`${err}`);
+  }
+}
+async function getConfig(create = false) {
+  if (create) {
+    const created = await ensureConfigFile();
+    if (created !== true) return created;
+  }
+  const configStr = await getConfigFile();
+  if (configStr instanceof Error) return configStr;
+  const parsed = parseConfigFile(configStr);
+  if (parsed instanceof Error) return parsed;
+  return parsed;
+}
+async function updateConfig(updater, create = false) {
+  const currentConfig = await getConfig(create);
+  if (currentConfig instanceof Error) return currentConfig;
+  const updatedConfig = typeof updater === "function" ? updater(currentConfig) : { ...currentConfig, ...updater };
+  const stringified = JSON.stringify(updatedConfig, null, 2);
+  await fs.writeFile(mxfbConfigFilePath, stringified, { encoding: "utf-8" });
+  return true;
+}
+export {
+  createConfigFile,
+  deleteConfigDir,
+  deleteConfigFile,
+  emptyConfigObj,
+  ensureConfigFile,
+  getConfig,
+  getConfigFile,
+  parseConfigFile,
+  updateConfig,
+  validateConfigObj
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxfb/tools",
-  "version": "0.0.43",
+  "version": "0.2.3",
   "description": "",
   "author": "Maxime Fabas",
   "license": "ISC",
@@ -11,32 +11,31 @@
   "type": "module",
   "main": "index.js",
   "module": "index.js",
-  "dependencies": {},
   "peerDependencies": {
+    "@design-edito/tools": "^0.1.73",
     "chalk": "^5.3.0",
     "fs-extra": "^11.2.0",
-    "get-image-colors": "^4.0.1",
-    "jsdom": "^24.0.0",
+    "jsdom": "^24.1.1",
     "node-fetch": "^3.3.2",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "sharp": "^0.33.3"
   },
   "devDependencies": {
-    "@types/chalk": "^2.2.0",
-    "@types/fs-extra": "^11.0.4",
-    "@types/get-image-colors": "^4.0.5",
-    "@types/jsdom": "^21.1.6",
-    "@types/node": "^20.12.5",
+    "@types/node": "^22.15.21",
     "@types/prompts": "^2.4.9",
-    "@types/react": "^18.2.74",
-    "@types/react-dom": "^18.2.24",
-    "@types/semver": "^7.5.8",
-    "camelcase": "^8.0.0",
-    "esbuild": "^0.20.2",
+    "@types/semver": "^7.7.0",
+    "chalk": "^5.4.1",
+    "chokidar-cli": "^3.0.0",
+    "concurrently": "^9.1.2",
+    "esbuild": "^0.25.5",
     "prompts": "^2.4.2",
-    "semver": "^7.6.0",
-    "simple-git": "^3.24.0",
-    "typescript": "^5.4.4"
+    "puppeteer": "^24.9.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "semver": "^7.7.2",
+    "sharp": "^0.34.2",
+    "simple-git": "^3.27.0",
+    "typescript": "^5.8.3"
   }
 }