@constl/utils-tests 1.6.15 → 2.0.0

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const sousDossier: ({ dossier, i }: {
+    dossier: string;
+    i: number;
+}) => string;

package/dist/utils.js

@@ -0,0 +1,5 @@
+import { join } from "path";
+export const sousDossier = ({ dossier, i }) => {
+    return join(dossier, i.toString());
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC,EAAkC,EAAE,EAAE;IAC5E,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;AACrC,CAAC,CAAC"}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.6.15";
+export declare const version = "2.0.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = "1.6.15";
+export const version = "2.0.0";
 //# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC"}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.6.15",
+  "version": "2.0.0",
   "license": "AGPL-3.0-or-later",
   "name": "@constl/utils-tests",
   "author": "Julien Jean Malard-Adam",
@@ -20,68 +20,68 @@
     "postbuild": "./dist/**/*"
   },
   "devDependencies": {
-    "@chainsafe/libp2p-noise": "^16.0.1",
-    "@chainsafe/libp2p-yamux": "^7.0.1",
-    "@constl/bohr-db": "^1.2.2",
-    "@constl/ipa": "1.5.13",
-    "@eslint/js": "^9.20.0",
-    "@libp2p/circuit-relay-v2": "^3.1.13",
-    "@libp2p/crypto": "^5.0.11",
-    "@libp2p/identify": "^3.0.19",
-    "@libp2p/interface": "^2.5.0",
-    "@libp2p/websockets": "^9.1.5",
-    "@multiformats/multiaddr": "^12.3.5",
-    "@multiformats/multiaddr-matcher": "^1.6.0",
-    "@orbitdb/core-types": "^1.0.13",
-    "@orbitdb/feed-db": "^1.1.1",
+    "@chainsafe/libp2p-noise": "^16.1.4",
+    "@chainsafe/libp2p-yamux": "^7.0.4",
+    "@constl/bohr-db": "^1.3.1",
+    "@constl/ipa": "1.6.24",
+    "@eslint/js": "^9.32.0",
+    "@libp2p/circuit-relay-v2": "^3.2.23",
+    "@libp2p/crypto": "^5.1.7",
+    "@libp2p/identify": "^3.0.38",
+    "@libp2p/interface": "^2.10.5",
+    "@libp2p/websockets": "^9.2.18",
+    "@multiformats/multiaddr": "^12.5.1",
+    "@multiformats/multiaddr-matcher": "^2.0.2",
+    "@orbitdb/core-types": "^1.2.0",
+    "@orbitdb/feed-db": "^1.3.0",
     "@types/crypto-js": "^4.2.2",
     "@types/file-saver": "^2.0.7",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^22.13.4",
+    "@types/node": "^24.1.0",
     "@types/uuid": "^10.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.24.1",
-    "@typescript-eslint/parser": "^8.24.1",
-    "aegir": "^45.0.9",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "aegir": "^47.0.20",
     "ajv": "^8.17.1",
     "buffer": "^6.0.3",
-    "core-js": "^3.40.0",
-    "electron": "^34.2.0",
-    "esbuild": "^0.24.2",
-    "eslint": "^9.20.1",
+    "core-js": "^3.44.0",
+    "electron": "^37.2.4",
+    "esbuild": "^0.25.8",
+    "eslint": "^9.32.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^10.0.1",
+    "eslint-config-prettier": "^10.1.8",
     "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-n": "^17.15.1",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-n": "^17.21.3",
     "eslint-plugin-promise": "^7.2.1",
-    "execa": "^9.5.2",
-    "mocha": "^11.1.0",
-    "playwright": "^1.50.1",
-    "prettier": "^3.5.1",
+    "execa": "^9.6.0",
+    "mocha": "^11.7.1",
+    "playwright": "^1.54.1",
+    "prettier": "^3.6.2",
     "progress-events": "^1.0.1",
     "source-map-support": "^0.5.21",
     "ts-patch": "^3.3.0",
     "tsconfig-paths": "^4.2.0",
     "tscpaths": "^0.0.9",
-    "typescript": "5.7.3",
-    "typescript-eslint": "^8.24.1",
-    "typescript-transform-paths": "^3.5.3"
+    "typescript": "5.8.3",
+    "typescript-eslint": "^8.38.0",
+    "typescript-transform-paths": "^3.5.5"
   },
   "dependencies": {
-    "@chainsafe/libp2p-gossipsub": "14.1.0",
-    "@helia/block-brokers": "^4.0.4",
-    "@libp2p/peer-id": "^5.0.12",
-    "@libp2p/webrtc": "^5.1.1",
-    "@orbitdb/core": "^2.4.3",
-    "blockstore-core": "^5.0.2",
-    "blockstore-level": "^2.0.1",
+    "@chainsafe/libp2p-gossipsub": "14.1.1",
+    "@helia/block-brokers": "^4.2.3",
+    "@libp2p/peer-id": "^5.1.8",
+    "@libp2p/webrtc": "^5.2.23",
+    "@orbitdb/core": "^3.0.2",
+    "blockstore-core": "^5.0.4",
+    "blockstore-level": "^2.0.3",
     "browserify-fs": "^1.0.0",
     "chokidar": "^4.0.3",
     "crypto-browserify": "^3.12.1",
     "events": "^3.3.0",
     "genversion": "^3.2.0",
-    "helia": "5.2.1",
-    "libp2p": "^2.6.3",
+    "helia": "5.5.0",
+    "libp2p": "^2.9.0",
     "os-browserify": "^0.3.0",
     "process": "^0.11.10",
     "read-package-up": "^11.0.0",
@@ -89,7 +89,7 @@
     "stream-browserify": "^3.0.0",
     "uint8arrays": "^5.1.0",
     "url-polyfill": "^1.1.13",
-    "uuid": "^11.0.5",
+    "uuid": "^11.1.0",
     "wherearewe": "^2.0.1"
   },
   "scripts": {

package/renovate.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:base"],
+  "extends": ["config:recommended"],
   "packageRules": [
     {
       "matchDepTypes": ["devDependencies"],
@@ -12,8 +12,8 @@
       "automerge": true
     },
     {
-      "matchPackagePatterns": ["^actions/"],
-      "automerge": true
+      "automerge": true,
+      "matchPackageNames": ["/^actions//"]
     },
     {
       "description": "Regrouper les librairies @constl.",
@@ -27,7 +27,13 @@
       "groupName": "Libp2p et Helia",
       "groupSlug": "libp2p-helia-node",
       "matchDatasources": ["npm"],
-      "matchPackageNames": ["@libp2p/**", "@chainsafe/**", "libp2p", "helia"]
+      "matchPackageNames": [
+        "@libp2p/**",
+        "@chainsafe/**",
+        "@helia/**",
+        "libp2p",
+        "helia"
+      ]
     }
   ]
 }

package/src/attente.ts

@@ -1,165 +1,138 @@
-import { EventEmitter } from "events";
-import { v4 as uuidv4 } from "uuid";
-import { isBrowser, isWebWorker } from "wherearewe";
-import type { Download } from "playwright";
-
-export class AttendreRésultat<T> {
-  val?: T;
-  fsOublier: { [clef: string]: () => void };
-  événements: EventEmitter;
-
-  constructor() {
-    this.événements = new EventEmitter();
-    this.val = undefined;
-    this.fsOublier = {};
-  }
-
-  mettreÀJour(x?: T) {
-    this.val = x;
-    this.événements.emit("changé");
-  }
-
-  async attendreQue(f: (x: T) => boolean | Promise<boolean>): Promise<T> {
-    if (this.val !== undefined && (await f(this.val))) return this.val;
-    const id = uuidv4();
-
-    return new Promise((résoudre) => {
-      const fLorsqueChangé = async () => {
-        if (this.val !== undefined && (await f(this.val))) {
-          this.oublier(id);
-          résoudre(this.val);
-        }
-      };
-      this.événements.on("changé", fLorsqueChangé);
-      this.fsOublier[id] = () => this.événements.off("changé", fLorsqueChangé);
-    });
-  }
-
-  async attendreExiste(): Promise<T> {
-    const val = (await this.attendreQue((x) => !!x)) as T;
-    return val;
-  }
-
-  async attendreNexistePas(): Promise<void> {
-    if (this.val === undefined) return;
-
-    const id = uuidv4();
-
-    return new Promise((résoudre) => {
-      const fLorsqueChangé = async () => {
-        if (this.val === undefined) {
-          this.oublier(id);
-          résoudre();
-        }
-      };
-      this.événements.on("changé", fLorsqueChangé);
-      this.fsOublier[id] = () => this.événements.off("changé", fLorsqueChangé);
-    });
-  }
-
-  oublier(id: string) {
-    this.fsOublier[id]();
-    delete this.fsOublier[id];
-  }
-
-  toutAnnuler() {
-    Object.keys(this.fsOublier).forEach((id) => this.oublier(id));
+import { isBrowser, isElectronRenderer } from "wherearewe";
+
+export const que = async <T>(
+  f: () => T | Promise<T | undefined>,
+  t = 100,
+): Promise<T> => {
+  return new Promise<T>((résoudre) => {
+    const testF = async () => {
+      const résultat = await f();
+      if (résultat !== undefined) {
+        résoudre(résultat);
+      } else {
+        setTimeout(testF, t);
+      }
+    };
+    testF();
+  });
+};
+
+export const attendreFichierExiste = async ({
+  fichier,
+  signal,
+}: {
+  fichier: string;
+  signal?: AbortSignal;
+}): Promise<boolean> => {
+  if (isBrowser || isElectronRenderer) {
+    throw new Error("Test non disponible dans le navigateur.");
   }
-}
-
-export class AttendreFichierExiste extends EventEmitter {
-  fOublier?: () => void;
+  const chokidar = await import("chokidar");
+  const fs = await import("fs");
+  const path = await import("path");
+
+  return new Promise<boolean>((résoudre) => {
+    // Arrêter tout de suite si le fichier existe déjà
+    if (fs.existsSync(fichier)) résoudre(true);
+
+    // Actions signal
+    const lorsqueAvorté = () => {
+      fermerEtRésoudre(false);
+    };
+
+    // Actions écouteur de fichiers
+    const dossier = path.dirname(fichier);
+    const écouteur = chokidar.watch(dossier);
+    const fermerÉcouteur = async () => await écouteur.close();
+
+    const lorsquFichierAjouté = () => {
+      if (fs.existsSync(fichier)) {
+        fermerEtRésoudre(true);
+      }
+    };
+
+    // Fermeture des écouteurs
+    const fermerEtRésoudre = async (statut: boolean) => {
+      signal?.removeEventListener("abort", lorsqueAvorté);
+      écouteur.off("add", lorsquFichierAjouté);
+      await fermerÉcouteur();
+
+      résoudre(statut);
+    };
+
+    signal?.addEventListener("abort", lorsqueAvorté);
+
+    écouteur.on("add", lorsquFichierAjouté);
+    if (signal?.aborted) fermerEtRésoudre(false);
+
+    if (fs.existsSync(fichier)) fermerEtRésoudre(true);
+  });
+};
+
+export const attendreFichierModifié = async ({
+  fichier,
+  condition,
+  signal,
+}: {
   fichier: string;
-  attenteTéléchargement?: Promise<Download>;
-
-  constructor(fichier: string) {
-    super();
-    this.fichier = fichier;
+  condition?: () => Promise<boolean>;
+  signal?: AbortSignal;
+}) => {
+  if (isBrowser || isElectronRenderer) {
+    throw new Error("Test non disponible dans le navigateur.");
   }
 
-  async attendre(): Promise<void> {
-    if (isBrowser || isWebWorker) {
-      throw new Error("Test non disponible dans le navigateur.");
-    } else {
-      const chokidar = await import("chokidar");
-      const fs = await import("fs");
-      const path = await import("path");
-
-      await new Promise<void>((résoudre) => {
-        if (fs.existsSync(this.fichier)) résoudre();
-        const dossier = path.dirname(this.fichier);
-        const écouteur = chokidar.watch(dossier);
-        this.fOublier = () => écouteur.close();
-        écouteur.on("add", async () => {
-          if (fs.existsSync(this.fichier)) {
-            await écouteur.close();
-            résoudre();
-          }
-        });
-        if (fs.existsSync(this.fichier)) {
-          écouteur.close();
-          résoudre();
+  await attendreFichierExiste({ fichier, signal });
+  const tempsAvant = Date.now();
+
+  const chokidar = await import("chokidar");
+  const fs = await import("fs");
+
+  return new Promise((résoudre) => {
+    // Actions signal
+    const lorsqueAvorté = () => {
+      fermerEtRésoudre(false);
+    };
+
+    // Actions écouteur de fichiers
+    const écouteur = chokidar.watch(fichier);
+    const fermerÉcouteur = async () => await écouteur.close();
+    const lorsqueModifié = async (adresse: string) => {
+      if (adresse !== fichier) return;
+      await vérifierModifié();
+    };
+
+    const fermerEtRésoudre = async (statut: boolean) => {
+      clearInterval(intervale);
+      signal?.removeEventListener("abort", lorsqueAvorté);
+      écouteur.off("change", lorsqueModifié);
+      await fermerÉcouteur();
+
+      résoudre(statut);
+    };
+
+    const vérifierModifié = async () => {
+      try {
+        const { mtime } = fs.statSync(fichier);
+        const prêt = mtime.getTime() > tempsAvant;
+
+        if (prêt && (!condition || (await condition()))) {
+          fermerEtRésoudre(true);
         }
-      });
-    }
-  }
+      } catch (e) {
+        // Le fichier a été effacé
+        await fermerEtRésoudre(false);
+      }
+    };
 
-  annuler() {
-    this.fOublier?.();
-  }
-}
+    signal?.addEventListener("abort", lorsqueAvorté);
 
-export class AttendreFichierModifié extends EventEmitter {
-  fsOublier: (() => void)[];
-  fichier: string;
-  attendreExiste: AttendreFichierExiste;
-
-  constructor(fichier: string) {
-    super();
-    this.fichier = fichier;
-    this.attendreExiste = new AttendreFichierExiste(fichier);
-    this.fsOublier = [];
-    this.fsOublier.push(() => this.attendreExiste.annuler());
-  }
+    écouteur.on("change", lorsqueModifié);
+    écouteur.on("unlink", lorsqueModifié);
 
-  async attendre(
-    tempsAvant: number,
-    condition?: () => Promise<boolean>,
-  ): Promise<void> {
-    await this.attendreExiste.attendre();
-    const chokidar = await import("chokidar");
-    const fs = await import("fs");
-    return new Promise((résoudre, rejeter) => {
-      const écouteur = chokidar.watch(this.fichier);
-      this.fsOublier.push(() => écouteur.close());
-
-      const vérifierModifié = async () => {
-        try {
-          const { mtime } = fs.statSync(this.fichier);
-          const prêt = mtime.getTime() > tempsAvant;
-
-          if (prêt && (!condition || (await condition()))) {
-            await écouteur.close();
-            clearInterval(intervale);
-            résoudre();
-          }
-        } catch (e) {
-          // Le fichier a été effacé
-          écouteur.close();
-          rejeter(e);
-        }
-      };
-
-      écouteur.on("change", async (adresse) => {
-        if (adresse !== this.fichier) return;
-        await vérifierModifié();
-      });
-      // Parfois, on dirait que chokidar ne détecte pas l'événement...
-      const intervale = setInterval(vérifierModifié, 1000);
-    });
-  }
+    if (signal?.aborted) fermerEtRésoudre(false);
 
-  annuler() {
-    this.fsOublier.forEach((f) => f());
-  }
-}
+    // Parfois, on dirait que chokidar ne détecte pas l'événement...
+    const intervale = setInterval(vérifierModifié, 1000);
+  });
+};

package/src/config.ts

@@ -1,7 +1,7 @@
 import type { PartialOptions } from "aegir";
 import type { BuildOptions } from "esbuild";
 
-import { lancerRelai } from "./sfip.js";
+import { lancerRelai } from "./relai/index.js";
 
 export const obtConfigEsbuild = async (): Promise<BuildOptions> => {
   const { createRequire } = (await import("module")).default;
@@ -11,7 +11,7 @@ export const obtConfigEsbuild = async (): Promise<BuildOptions> => {
   const __dirname = path.dirname(fileURLToPath(import.meta.url));
   const require = createRequire(import.meta.url);
   const configEsbuild: BuildOptions = {
-    // this will inject all the named exports from 'node-globals.js' as globals
+    // ceci injecte les exportations nomées de 'node-globals.js' en tant que variables globales
     inject: [path.join(__dirname, "./scripts/node-globals.js")],
     plugins: [
       {
@@ -64,7 +64,13 @@ type RetourAvant = {
   relai?: () => void;
 };
 
-export const générerConfigÆgir = async (): Promise<PartialOptions> => {
+export const générerConfigÆgir = async ({
+  portDéfautRelai,
+  clefPrivéeRelai,
+}: {
+  portDéfautRelai?: string;
+  clefPrivéeRelai?: string;
+} = {}): Promise<PartialOptions> => {
   const esbuild = await obtConfigEsbuild();
   return {
     test: {
@@ -72,7 +78,7 @@ export const générerConfigÆgir = async (): Promise<PartialOptions> => {
       before: async (opts): Promise<RetourAvant> => {
         let relai = undefined;
         if (opts.target.includes("browser")) {
-          relai = await lancerRelai();
+          relai = await lancerRelai({ portDéfautRelai, clefPrivéeRelai });
         }
 
         return { relai };

package/src/constellation.ts

@@ -1,78 +1,58 @@
-import type { réseau, client, Constellation } from "@constl/ipa";
-import type { OrbitDB } from "@orbitdb/core";
 import { isBrowser } from "wherearewe";
+import { créerOrbitesTest } from "./orbite.js";
+import { dossierTempo } from "./dossiers.js";
+import { OrbitDB } from "@orbitdb/core";
 
-import { créerOrbiteTest } from "@/orbite.js";
-import { AttendreRésultat } from "@/attente.js";
-import type { ServicesLibp2pConstlTest } from "./libp2p";
+interface InterfaceConstellation {
+  fermer: () => Promise<void>;
+}
+
+interface OptionsConstellation {
+  dossier?: string;
+  orbite?: OrbitDB;
+}
 
 export const créerConstellationsTest = async <
-  T = Constellation,
-  U = client.optsConstellation,
+  T extends InterfaceConstellation,
 >({
   n = 1,
   créerConstellation,
+  dossier,
 }: {
   n: number;
-  créerConstellation: (opts: U) => T;
+  créerConstellation: (opts: OptionsConstellation) => T;
+  dossier?: string;
 }): Promise<{
-  clients: ReturnType<typeof créerConstellation>[];
-  orbites: OrbitDB<ServicesLibp2pConstlTest>[];
-  fOublier: () => Promise<void>;
+  constls: T[];
+  fermer: () => Promise<void>;
 }> => {
-  const clients: ReturnType<typeof créerConstellation>[] = [];
-  const fsOublier: (() => Promise<void>)[] = [];
-
-  // Nécessaire pour Playwright
-  if (isBrowser) window.localStorage.clear();
+  let effacerDossier: () => void = () => {};
+  if (!dossier) {
+    ({ dossier, effacer: effacerDossier } = await dossierTempo());
+  }
 
-  const { orbites, fOublier: fOublierOrbites } = await créerOrbiteTest({ n });
-  fsOublier.push(fOublierOrbites);
+  const { orbites, fermer: fermerOrbites } = await créerOrbitesTest({
+    n,
+    dossier,
+  });
 
+  const constls: T[] = [];
   for (const i in [...Array(n).keys()]) {
-    const client = créerConstellation({
+    const constl = créerConstellation({
       orbite: orbites[i],
-      dossier: orbites[i].directory.split("/").slice(0, -1).join("/"),
-    } as U);
-    clients.push(client);
+      dossier,
+    });
+    constls.push(constl);
   }
 
-  const fOublier = async () => {
-    for (const client of clients) await (client as Constellation).fermer();
-    await Promise.all(fsOublier.map((f) => f()));
-  };
-  return { fOublier, clients, orbites };
-};
-
-export const constellationConnectéeÀ = async (
-  constellation: client.Constellation,
-  connectéeÀ: client.Constellation,
-): Promise<void> => {
-  const dispositifsConnectés = new AttendreRésultat<
-    réseau.statutDispositif[]
-  >();
-  const idCompte2 = await connectéeÀ.obtIdCompte();
+  const fermer = async () => {
+    for (const constl of constls) await constl.fermer();
 
-  const fOublier = await constellation.réseau.suivreConnexionsDispositifs({
-    f: (dispositifs) => dispositifsConnectés.mettreÀJour(dispositifs),
-  });
-  await dispositifsConnectés.attendreQue((dispositifs) => {
-    return !!dispositifs.find((d) => d.infoDispositif.idCompte === idCompte2);
-  });
-  await fOublier();
-  return;
-};
+    await fermerOrbites();
+    effacerDossier();
 
-export const constellationsConnectées = async (
-  ...clients: client.Constellation[]
-): Promise<void> => {
-  if (clients.length < 2) return;
-  const promesses: Promise<void>[] = [];
-  for (let i = 1; i < clients.length; i++) {
-    for (let j = 0; j < i; j++) {
-      promesses.push(constellationConnectéeÀ(clients[i], clients[j]));
-      promesses.push(constellationConnectéeÀ(clients[j], clients[i]));
-    }
-  }
-  await Promise.all(promesses);
+    // Nécessaire pour Playwright
+    if (isBrowser) window.localStorage.clear();
+  };
+  return { constls, fermer };
 };