@mxfb/tools 0.2.3 → 0.3.0

package/chunks/chunk-W7YBGJ4H.js

@@ -0,0 +1,28 @@
+// src/agnostic/misc/assert/index.ts
+var Assert;
+((Assert2) => {
+  function makeSuccess(label) {
+    console.info(`\u2705 SUCCESS: "${label}"`);
+  }
+  function makeFailure(label) {
+    throw new Error(`\u{1F6AB} FAILURE: "${label}""`);
+  }
+  function assert(label, assertion) {
+    if (Array.isArray(assertion)) assertion.forEach((innerAssertion, pos) => assert(`${label} (${pos})`, innerAssertion));
+    else if (typeof assertion === "function") {
+      try {
+        const result = assertion();
+        if (result === false) makeFailure(label);
+        else makeSuccess(label);
+      } catch (err) {
+        makeFailure(`${err}`);
+      }
+    } else if (assertion === false) makeFailure(label);
+    else makeSuccess(label);
+  }
+  Assert2.assert = assert;
+})(Assert || (Assert = {}));
+
+export {
+  Assert
+};

package/chunks/chunk-WLL3FNVL.js

@@ -0,0 +1,40 @@
+// src/agnostic/misc/random/index.ts
+var Random;
+((Random2) => {
+  function random(bound1 = 1, bound2) {
+    const min = bound2 === void 0 ? 0 : bound1;
+    const max = bound2 === void 0 ? bound1 : bound2;
+    if (min === max || min > max) return void 0;
+    const range = max - min;
+    return Math.random() * range + min;
+  }
+  Random2.random = random;
+  function randomInt(...args) {
+    const rand = random(...args);
+    return rand !== void 0 ? Math.floor(rand) : void 0;
+  }
+  Random2.randomInt = randomInt;
+  Random2.hexChars = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+  function randomHexChar() {
+    const nbr = Math.floor(Math.random() * 16);
+    const char = Random2.hexChars[nbr];
+    return char;
+  }
+  Random2.randomHexChar = randomHexChar;
+  function randomHash(length = 4) {
+    return new Array(length).fill(null).map(randomHexChar).join("");
+  }
+  Random2.randomHash = randomHash;
+  function randomHashPattern(pattern, joiner = "-") {
+    return pattern.map(randomHash).join(joiner);
+  }
+  Random2.randomHashPattern = randomHashPattern;
+  function randomUUID() {
+    return randomHashPattern([8, 4, 4, 4, 12]);
+  }
+  Random2.randomUUID = randomUUID;
+})(Random || (Random = {}));
+
+export {
+  Random
+};

package/chunks/chunk-WOAYU6LB.js

@@ -0,0 +1,13 @@
+import {
+  isInEnum
+} from "./chunk-E6MSDKON.js";
+
+// src/agnostic/objects/enums/index.ts
+var Enums;
+((Enums2) => {
+  Enums2.isInEnum = isInEnum;
+})(Enums || (Enums = {}));
+
+export {
+  Enums
+};

package/chunks/chunk-XA4HVHJ4.js

@@ -0,0 +1,18 @@
+// src/agnostic/html/insert-node/index.ts
+function insertNode(node, position, reference) {
+  if (position === "after") {
+    if (reference.nextSibling !== null) reference.parentNode?.insertBefore(node, reference.nextSibling);
+    else reference.parentNode?.appendChild(node);
+  } else if (position === "before") {
+    reference.parentNode?.insertBefore(node, reference);
+  } else if (position === "startof") {
+    if (reference.firstChild !== null) reference.insertBefore(node, reference.firstChild);
+    else reference.appendChild(node);
+  } else {
+    reference.appendChild(node);
+  }
+}
+
+export {
+  insertNode
+};

package/chunks/chunk-XN3PZIVL.js

@@ -0,0 +1,38 @@
+import {
+  register
+} from "./chunk-KQT5CTGF.js";
+import {
+  Crossenv
+} from "./chunk-GJOU3UAL.js";
+
+// src/agnostic/html/selector-to-element/index.ts
+function selectorToElement(selector, documentObj) {
+  const actualDocument = documentObj ?? Crossenv.getDocument();
+  if (actualDocument === null) throw register.getError("no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */, "The optional second parameter expects a Document object");
+  const tagRegexp = /^[A-Za-z]+/;
+  const idRegexp = /#[A-Za-z]+[\w\-\:]*/;
+  const classRegexp = /\.[A-Za-z]+[\w\-]*/;
+  const attributeRegexp = /\[[A-Za-z]+[\w\-]*(="[\w\-]+")?\]/;
+  const matchedTags = selector.match(tagRegexp) ?? [];
+  const matchedIds = selector.match(idRegexp) ?? [];
+  const matchedClasses = selector.match(classRegexp) ?? [];
+  const matchedAttrs = selector.match(attributeRegexp) ?? [];
+  const tag = matchedTags[matchedTags.length - 1] ?? "div";
+  const id = matchedIds[matchedIds.length - 1] ?? null;
+  const classes = matchedClasses.map((matchedClass) => matchedClass.replace(/^\./, ""));
+  const attributes = matchedAttrs.map((matchedAttr) => matchedAttr.replace(/^\[/, "").replace(/\]$/, "").split("="));
+  const element = actualDocument.createElement(tag);
+  if (id !== null) {
+    element.id = id;
+  }
+  element.classList.add(...classes);
+  attributes.forEach(([name, value = ""]) => {
+    if (name === void 0) return;
+    element.setAttribute(name, value);
+  });
+  return element;
+}
+
+export {
+  selectorToElement
+};

package/chunks/chunk-Y3OZHZUF.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 isTiebreak = aSets === bSets && aSets === upTo;
+            if (isTiebreak) 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-YDIBNEGA.js

@@ -0,0 +1,9 @@
+// src/agnostic/objects/is-record/index.ts
+function isRecord(input) {
+  if (typeof input !== "object" || input === null) return false;
+  return Object.keys(input).every((key) => typeof key === "string");
+}
+
+export {
+  isRecord
+};

package/components/Comp/index.d.ts

@@ -0,0 +1 @@
+export default function Comp(): import("react/jsx-runtime").JSX.Element;

package/index.d.ts

@@ -0,0 +1,3 @@
+export { Agnostic } from './agnostic';
+export { Components } from './components';
+export { Node } from './node';

package/node/files/index.d.ts

@@ -0,0 +1,9 @@
+import { isInDirectory as isInDirectoryFunc } from './is-in-directory';
+import { ReadWriteEditorFunc as ReadWriteEditorFuncType, readWrite as readWriteFunc } from './read-write';
+import { Subpaths as SubpathsNamespace } from './subpaths';
+export declare namespace Files {
+    const isInDirectory: typeof isInDirectoryFunc;
+    type ReadWriteEditorFunc = ReadWriteEditorFuncType;
+    const readWrite: typeof readWriteFunc;
+    export import Subpaths = SubpathsNamespace;
+}

package/node/files/index.js

@@ -0,0 +1,21 @@
+import {
+  Subpaths
+} from "../../chunks/chunk-HGCG2J77.js";
+import {
+  isInDirectory
+} from "../../chunks/chunk-NRITRUZW.js";
+import {
+  readWrite
+} from "../../chunks/chunk-7DBNMU6N.js";
+import "../../chunks/chunk-LQFKUNVQ.js";
+
+// src/node/files/index.ts
+var Files;
+((Files2) => {
+  Files2.isInDirectory = isInDirectory;
+  Files2.readWrite = readWrite;
+  Files2.Subpaths = Subpaths;
+})(Files || (Files = {}));
+export {
+  Files
+};

package/node/files/is-in-directory/index.d.ts

@@ -0,0 +1 @@
+export declare function isInDirectory(childPath: string, parentPath: string): boolean;

package/node/files/is-in-directory/index.js

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

package/node/files/read-write/index.d.ts

@@ -0,0 +1,9 @@
+import { promises as fs } from 'node:fs';
+type Path = Parameters<typeof fs.writeFile>[0];
+type ReadFileData = Awaited<ReturnType<typeof fs.readFile>>;
+type WriteFileData = Parameters<typeof fs.writeFile>[1];
+type ReadOptions = Parameters<typeof fs.readFile>[1];
+type WriteOptions = Parameters<typeof fs.writeFile>[2];
+export type ReadWriteEditorFunc = (curr: ReadFileData) => WriteFileData;
+export declare function readWrite(path: Path, editor: ReadWriteEditorFunc, ...options: [ReadOptions?, WriteOptions?]): Promise<string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView> | import("stream").Stream>;
+export {};

package/node/files/read-write/index.js

@@ -0,0 +1,6 @@
+import {
+  readWrite
+} from "../../../chunks/chunk-7DBNMU6N.js";
+export {
+  readWrite
+};

package/node/files/subpaths/index.d.ts

@@ -0,0 +1,34 @@
+import { Stats } from 'node:fs';
+export declare namespace Subpaths {
+    export type ChildType = 'file' | 'directory' | 'symlink';
+    export type ChildDetails = {
+        type: ChildType;
+        hidden: boolean;
+        realPath: string;
+    };
+    export type ListContext = {
+        depth?: number;
+        lstats?: Stats | null;
+        rootPath?: string | null;
+    };
+    export const defaultListContext: Required<ListContext>;
+    export const fillListContext: (input: ListContext) => Required<ListContext>;
+    export type ListOptions = {
+        directories?: boolean;
+        files?: boolean;
+        symlinks?: boolean;
+        hidden?: boolean;
+        followSimlinks?: boolean;
+        dedupeSimlinksContents?: boolean;
+        maxDepth?: number;
+        returnRelative?: boolean;
+        exclude?: RegExp | string | (RegExp | string)[] | null;
+        include?: RegExp | string | (RegExp | string)[] | null;
+        filter?: ((path: string, details: ChildDetails) => boolean | Promise<boolean>);
+    };
+    export const defaultListOptions: Required<ListOptions>;
+    export const fillOptions: (input: ListOptions) => Required<ListOptions>;
+    export function list(...args: Parameters<typeof listAbsoluteSubpaths>): Promise<string[]>;
+    function listAbsoluteSubpaths(inputPath: string, _options?: ListOptions, __private_context?: ListContext): Promise<string[]>;
+    export {};
+}

package/node/files/subpaths/index.js

@@ -0,0 +1,7 @@
+import {
+  Subpaths
+} from "../../../chunks/chunk-HGCG2J77.js";
+import "../../../chunks/chunk-LQFKUNVQ.js";
+export {
+  Subpaths
+};

package/node/image/index.d.ts

@@ -0,0 +1,9 @@
+export declare function getImageColorsFromUrl(url: string): Promise<string[]>;
+export declare const compressorExtensions: {
+    jpgExtensions: string[];
+    pngExtensions: string[];
+    webpExtensions: string[];
+    avifExtensions: string[];
+    heifExtensions: string[];
+};
+export declare function compressImages(src: string, preExtension: string, sizes?: number[], qualities?: number[] | number): Promise<void>;

package/node/image/index.js

@@ -0,0 +1,74 @@
+// src/node/image/index.ts
+import path from "node:path";
+import fetch from "node-fetch";
+import getColors from "get-image-colors";
+import fse from "fs-extra";
+import sharp from "sharp";
+async function getImageColorsFromUrl(url) {
+  const data = await fetch(url);
+  const blob = await data.blob();
+  const arrayBuffer = await blob.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  const colors = await getColors(buffer, blob.type);
+  const result = colors.map((color) => color.hex());
+  return result;
+}
+var compressorExtensions = {
+  jpgExtensions: [".jpg", ".jpeg"],
+  pngExtensions: [".png"],
+  webpExtensions: [".wepb"],
+  avifExtensions: [".avif", ".avifs"],
+  heifExtensions: [".heif", ".heifs", ".hif"]
+};
+async function compressImages(src, preExtension, sizes = [], qualities = 100) {
+  if (!path.isAbsolute(src)) throw new Error("Source path must be absolute.");
+  const files = await fse.readdir(src);
+  const {
+    jpgExtensions,
+    pngExtensions,
+    webpExtensions,
+    avifExtensions,
+    heifExtensions
+  } = compressorExtensions;
+  const allowedExtensions = [
+    ...jpgExtensions,
+    ...pngExtensions,
+    ...webpExtensions,
+    ...avifExtensions,
+    ...heifExtensions
+  ].flat();
+  for (const file of files) {
+    const filePath = path.join(src, file);
+    const isDirectory = (await fse.stat(filePath)).isDirectory();
+    if (isDirectory) continue;
+    const ext = path.extname(file);
+    const extIsAllowed = allowedExtensions.includes(ext.toLowerCase());
+    if (!extIsAllowed) continue;
+    const nameWithPreExt = file.replace(new RegExp(`${ext}$`), "");
+    let matchedPreExt = nameWithPreExt.split(".").slice(1).slice(-1)[0] ?? "";
+    const preExt = matchedPreExt === "" ? matchedPreExt : `.${matchedPreExt}`;
+    if (preExt === preExtension) continue;
+    const name = nameWithPreExt.replace(new RegExp(`${preExtension}$`), "");
+    for (const sizePos in sizes) {
+      const size = sizes[sizePos];
+      const dstFile = `${name}.${size}${preExtension}${ext}`;
+      const dstFilePath = path.join(src, dstFile);
+      const quality = Array.isArray(qualities) ? qualities[sizePos] ?? qualities.slice(-1)[0] ?? 100 : qualities;
+      const resized = sharp(filePath).withMetadata().resize(size, size, { fit: "inside", withoutEnlargement: true });
+      if (jpgExtensions.includes(ext)) await resized.jpeg({ quality }).toFile(dstFilePath);
+      if (pngExtensions.includes(ext)) await resized.png({ quality }).toFile(dstFilePath);
+      if (webpExtensions.includes(ext)) await resized.webp({ quality }).toFile(dstFilePath);
+      if (avifExtensions.includes(ext)) await resized.avif({ quality }).toFile(dstFilePath);
+      if (heifExtensions.includes(ext)) await resized.heif({ quality }).toFile(dstFilePath);
+      console.log(dstFilePath);
+      console.log("size", size);
+      console.log("quality", quality);
+      console.log("poids", (await fse.stat(dstFilePath)).size);
+    }
+  }
+}
+export {
+  compressImages,
+  compressorExtensions,
+  getImageColorsFromUrl
+};

package/node/process/index.d.ts

@@ -0,0 +1,8 @@
+import { beforeForcedExit as beforeForcedExitFunc, beforeExit as beforeExitFunc, onExit as onExitFunc, onAllExits as onAllExitsFunc } from './on-exit';
+export declare namespace Process {
+    const forceExitEvents: string[];
+    const beforeForcedExit: typeof beforeForcedExitFunc;
+    const beforeExit: typeof beforeExitFunc;
+    const onExit: typeof onExitFunc;
+    const onAllExits: typeof onAllExitsFunc;
+}

package/node/process/index.js

@@ -0,0 +1,20 @@
+import {
+  beforeExit,
+  beforeForcedExit,
+  forceExitEvents,
+  onAllExits,
+  onExit
+} from "../../chunks/chunk-LEXQ6E6L.js";
+
+// src/node/process/index.ts
+var Process;
+((Process2) => {
+  Process2.forceExitEvents = forceExitEvents;
+  Process2.beforeForcedExit = beforeForcedExit;
+  Process2.beforeExit = beforeExit;
+  Process2.onExit = onExit;
+  Process2.onAllExits = onAllExits;
+})(Process || (Process = {}));
+export {
+  Process
+};

package/node/process/on-exit/index.d.ts

@@ -0,0 +1,5 @@
+export declare const forceExitEvents: string[];
+export declare function beforeForcedExit(callback: () => void | Promise<void>): void;
+export declare function beforeExit(callback: () => void | Promise<void>): void;
+export declare function onExit(callback: () => void | Promise<void>): void;
+export declare function onAllExits(callback: () => void | Promise<void>): void;

package/node/process/on-exit/index.js

@@ -0,0 +1,14 @@
+import {
+  beforeExit,
+  beforeForcedExit,
+  forceExitEvents,
+  onAllExits,
+  onExit
+} from "../../../chunks/chunk-LEXQ6E6L.js";
+export {
+  beforeExit,
+  beforeForcedExit,
+  forceExitEvents,
+  onAllExits,
+  onExit
+};