@mxfb/tools 0.1.1 → 0.2.3

package/agnostic/index.d.ts

@@ -1,26 +1,4 @@
-import { Arrays as ArraysNamespace } from './arrays';
-import { Async as AsyncNamespace } from './async';
-import { Booleans as BooleansNamespace } from './booleans';
-import { Css as CssNamespace } from './css';
-import { Errors as ErrorsNamespace } from './errors';
-import { Html as HtmlNamespace } from './html';
-import { Misc as MiscNamespace } from './misc';
-import { Numbers as NumbersNamespace } from './numbers';
-import { Objects as ObjectsNamespace } from './objects';
-import { Optim as OptimNamespace } from './optim';
-import { Regexps as RegexpsNamespace } from './regexps';
-import { Strings as StringsNamespace } from './strings';
+import * as MiscNamespace from './misc';
 export declare namespace Agnostic {
-    export import Arrays = ArraysNamespace;
-    export import Async = AsyncNamespace;
-    export import Booleans = BooleansNamespace;
-    export import Css = CssNamespace;
-    export import Errors = ErrorsNamespace;
-    export import Html = HtmlNamespace;
     export import Misc = MiscNamespace;
-    export import Numbers = NumbersNamespace;
-    export import Objects = ObjectsNamespace;
-    export import Optim = OptimNamespace;
-    export import Regexps = RegexpsNamespace;
-    export import Strings = StringsNamespace;
 }

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

@@ -1,22 +1,6 @@
-import { Assert as AssertNamespace } from './assert';
-import { Cast as CastNamespace } from './cast';
-import { Crossenv as CrossenvNamespace } from './crossenv';
-import { getCurrentDownlink as getCurrentDownlinkFunc } from './get-current-downlink';
-import { ConstructorFunction as ConstructorFunctionType, isConstructorFunction as isConstructorFunctionFunc } from './is-constructor-function';
-import { Nullish as NullishType, isNullish as isNullishFunc, isNotNullish as isNotNullishFunc } from './is-nullish';
-import { Logs as LogsNamespace } from './logs';
-import { Random as RandomNamespace } from './random';
+import { Elo as EloNamespace } from './elo';
+import { Tennis as TennisNamespace } from './tennis';
 export declare namespace Misc {
-    export import Assert = AssertNamespace;
-    export import Cast = CastNamespace;
-    export import Crossenv = CrossenvNamespace;
-    const getCurrentDownlink: typeof getCurrentDownlinkFunc;
-    type ConstructorFunction = ConstructorFunctionType;
-    const isConstructorFunction: typeof isConstructorFunctionFunc;
-    const nullishValues: (null | undefined)[];
-    type Nullish = NullishType;
-    const isNullish: typeof isNullishFunc;
-    const isNotNullish: typeof isNotNullishFunc;
-    export import Logs = LogsNamespace;
-    export import Random = RandomNamespace;
+    export import Elo = EloNamespace;
+    export import Tennis = TennisNamespace;
 }

package/agnostic/misc/index.js

@@ -1,44 +1,15 @@
 import {
-  Cast
-} from "../../chunks/chunk-4QQBKBYH.js";
+  Elo
+} from "../../chunks/chunk-ZC5RZBNY.js";
 import {
-  getCurrentDownlink
-} from "../../chunks/chunk-7AWTHZLY.js";
-import {
-  Logs
-} from "../../chunks/chunk-5LNUCDQ6.js";
-import {
-  Assert
-} from "../../chunks/chunk-W7YBGJ4H.js";
-import {
-  Random
-} from "../../chunks/chunk-WLL3FNVL.js";
-import "../../chunks/chunk-QXAJXTXV.js";
-import {
-  isNotNullish,
-  isNullish,
-  nullishValues
-} from "../../chunks/chunk-HC6ZOHCS.js";
-import {
-  Crossenv
-} from "../../chunks/chunk-GJOU3UAL.js";
-import {
-  isConstructorFunction
-} from "../../chunks/chunk-RCO57B6F.js";
+  Tennis
+} from "../../chunks/chunk-TTZHPIH7.js";
 
 // src/agnostic/misc/index.ts
 var Misc;
 ((Misc2) => {
-  Misc2.Assert = Assert;
-  Misc2.Cast = Cast;
-  Misc2.Crossenv = Crossenv;
-  Misc2.getCurrentDownlink = getCurrentDownlink;
-  Misc2.isConstructorFunction = isConstructorFunction;
-  Misc2.nullishValues = nullishValues;
-  Misc2.isNullish = isNullish;
-  Misc2.isNotNullish = isNotNullish;
-  Misc2.Logs = Logs;
-  Misc2.Random = Random;
+  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

@@ -1,4 +1 @@
-import CompClass from './Comp';
-export declare namespace Components {
-    const Comp: typeof CompClass;
-}
+export declare namespace Components { }

package/node/index.d.ts

@@ -1,6 +1,2 @@
-import { Files as FilesNamespace } from './files';
-import { Process as ProcessNamespace } from './process';
-export declare namespace Node {
-    export import Files = FilesNamespace;
-    export import Process = ProcessNamespace;
-}
+import * as MxfbCliConfig from './mxfb-cli-config';
+export { MxfbCliConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxfb/tools",
-  "version": "0.1.1",
+  "version": "0.2.3",
   "description": "",
   "author": "Maxime Fabas",
   "license": "ISC",
@@ -12,9 +12,9 @@
   "main": "index.js",
   "module": "index.js",
   "peerDependencies": {
+    "@design-edito/tools": "^0.1.73",
     "chalk": "^5.3.0",
     "fs-extra": "^11.2.0",
-    "get-image-colors": "^4.0.1",
     "jsdom": "^24.1.1",
     "node-fetch": "^3.3.2",
     "react": "^18.3.1",
@@ -22,20 +22,20 @@
     "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.7",
-    "@types/node": "^22.1.0",
+    "@types/node": "^22.15.21",
     "@types/prompts": "^2.4.9",
-    "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0",
-    "@types/semver": "^7.5.8",
-    "camelcase": "^8.0.0",
-    "esbuild": "^0.23.0",
+    "@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.3",
-    "simple-git": "^3.25.0",
-    "typescript": "^5.5.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"
   }
 }