@constl/mandataire - npm Package Compare versions

Comparing version 1.0.2 to 2.0.0

dist/src/index.d.ts

@@ -1,2 +0,2 @@
-export { MandataireClientConstellation, ClientMandatairifiable, générerMandataire, } from "./mandataire.js";
+export { MandataireConstellation, Mandatairifiable, générerMandataire, } from "./mandataire.js";
 export { version } from "./version.js";

dist/src/index.js

@@ -1,3 +0,3 @@
-export { ClientMandatairifiable, générerMandataire, } from "./mandataire.js";
+export { Mandatairifiable, générerMandataire, } from "./mandataire.js";
 export { version } from "./version.js";
 //# sourceMappingURL=index.js.map

dist/src/mandataire.d.ts

@@ -1,4 +0,4 @@
-/// <reference types="node" />
-import { EventEmitter } from "events";
-import type { mandataire, types } from "@constl/ipa";
+import type TypedEmitter from "typed-emitter";
+import type { types } from "@constl/ipa";
+import { MessageActionDIpa, MessageDIpa, MessageErreurDIpa, MessagePourIpa, MessageSuivrePrêtDIpa } from "./messages.js";
 interface Tâche {
@@ -12,4 +12,16 @@ id: string;
 }
-export declare abstract class ClientMandatairifiable extends Callable {
-    événements: EventEmitter;
+export type ErreurMandataire = {
+    code: string;
+    erreur: string;
+    id?: string;
+};
+type ÉvénementsMandataire = {
+    message: (m: MessageDIpa) => void;
+    erreur: (e: ErreurMandataire) => void;
+};
+export declare abstract class Mandatairifiable extends Callable {
+    événements: TypedEmitter<ÉvénementsMandataire>;
+    événementsInternes: TypedEmitter<{
+        [id: string]: (x: MessageActionDIpa | MessageSuivrePrêtDIpa | MessageErreurDIpa) => void;
+    }>;
     tâches: {
@@ -34,11 +46,17 @@ [key: string]: Tâche;
     }): Promise<T>;
-    erreur({ erreur, id }: {
+    erreur({ erreur, code, id, }: {
         erreur: string;
+        code: string;
         id?: string;
     }): void;
     oublierTâche(id: string): Promise<void>;
-    abstract envoyerMessage(message: mandataire.messages.MessagePourTravailleur): void;
+    souleverErreur(): Promise<void>;
+    abstract envoyerMessageÀIpa(message: MessagePourIpa): void;
+    recevoirMessageDIpa(message: MessageDIpa): Promise<void>;
+    suivreErreurs({ f }: {
+        f: (x: ErreurMandataire) => void;
+    }): () => TypedEmitter<ÉvénementsMandataire>;
 }
-export type MandataireClientConstellation<T> = Required<T> & ClientMandatairifiable;
-export declare const générerMandataire: <T>(mandataireClient: ClientMandatairifiable) => MandataireClientConstellation<T>;
+export type MandataireConstellation<T> = Required<T> & Mandatairifiable;
+export declare const générerMandataire: <T>(mandataireClient: Mandatairifiable) => MandataireConstellation<T>;
 export {};

dist/src/mandataire.js

 import { v4 as uuidv4 } from "uuid";
-import { EventEmitter, once } from "events";
+import { EventEmitter } from "events";
+import { ERREUR_EXÉCUTION_IPA, ERREUR_FONCTION_MANQUANTE, ERREUR_FORMAT_ARGUMENTS, ERREUR_MESSAGE_INCONNU, ERREUR_MULTIPLES_FONCTIONS, ERREUR_PAS_UNE_FONCTION, } from "./codes.js";
+import { lorsque } from "./utils.js";
 class Callable extends Function {
@@ -13,4 +15,5 @@ // Code obtenu de https://hackernoon.com/creating-callable-objects-in-javascript-d21l3te1
 }
-export class ClientMandatairifiable extends Callable {
+export class Mandatairifiable extends Callable {
     événements;
+    événementsInternes;
     tâches;
@@ -21,40 +24,7 @@ erreurs;
         this.événements = new EventEmitter();
+        this.événementsInternes = new EventEmitter();
         this.tâches = {};
         this.erreurs = [];
         this.événements.on("message", (m) => {
-            const { type } = m;
-            switch (type) {
-                case "suivre": {
-                    const { id, données } = m;
-                    if (!this.tâches[id])
-                        return;
-                    const { fSuivre } = this.tâches[id];
-                    fSuivre(données);
-                    break;
-                }
-                case "suivrePrêt": {
-                    const { id, fonctions } = m;
-                    this.événements.emit(id, { fonctions });
-                    break;
-                }
-                case "action": {
-                    const { id, résultat } = m;
-                    this.événements.emit(id, { résultat });
-                    break;
-                }
-                case "erreur": {
-                    const { erreur, id } = m;
-                    if (id)
-                        this.événements.emit(id, { erreur });
-                    else
-                        this.erreur({ erreur, id });
-                    break;
-                }
-                default: {
-                    this.erreur({
-                        erreur: `Type inconnu ${type} dans message ${m}.`,
-                        id: m.id,
-                    });
-                }
-            }
+            this.recevoirMessageDIpa(m);
         });
@@ -65,2 +35,3 @@ }
             this.erreur({
+                code: ERREUR_FORMAT_ARGUMENTS,
                 erreur: `La fonction ${fonction.join(".")} fut appelée avec arguments ${args}. 
@@ -83,2 +54,3 @@ Toute fonction mandataire Constellation doit être appelée avec un seul argument en format d'objet (dictionnaire).`,
             this.erreur({
+                code: ERREUR_FONCTION_MANQUANTE,
                 erreur: "Aucun argument de nom " +
@@ -88,2 +60,3 @@ nomArgFonction +
                     fonction.join("."),
+                id,
             });
@@ -93,2 +66,3 @@ }
             this.erreur({
+                code: ERREUR_MULTIPLES_FONCTIONS,
                 erreur: "Plus d'un argument pour " +
@@ -103,2 +77,3 @@ fonction.join(".") +
             this.erreur({
+                code: ERREUR_PAS_UNE_FONCTION,
                 erreur: "Argument " + nomArgFonction + "n'est pas une fonction : ",
@@ -122,3 +97,3 @@ id,
             };
-            this.envoyerMessage(messageRetour);
+            this.envoyerMessageÀIpa(messageRetour);
         };
@@ -134,21 +109,22 @@ const tâche = {
         };
-        this.envoyerMessage(message);
-        const { fonctions, erreur } = (await once(this.événements, id))[0];
-        if (erreur) {
-            this.erreur({ erreur, id });
+        this.envoyerMessageÀIpa(message);
+        const retour = (await lorsque(this.événementsInternes, id))[0];
+        if (retour.type === "erreur") {
+            this.erreur({ erreur: retour.erreur, id, code: ERREUR_EXÉCUTION_IPA });
         }
-        if (fonctions && fonctions[0]) {
-            const retour = {
-                fOublier: fOublierTâche,
-            };
-            for (const f of fonctions) {
-                retour[f] = async (...args) => {
-                    await this.tâches[id]?.fRetour(f, args);
+        if (retour.type === "suivrePrêt") {
+            const { fonctions } = retour;
+            if (fonctions && fonctions[0]) {
+                const retour = {
+                    fOublier: fOublierTâche,
                 };
+                for (const f of fonctions) {
+                    retour[f] = async (...args) => {
+                        await this.tâches[id]?.fRetour(f, args);
+                    };
+                }
+                return retour;
             }
-            return retour;
         }
-        else {
-            return fOublierTâche;
-        }
+        return fOublierTâche;
     }
@@ -163,20 +139,16 @@ async appelerFonctionAction(id, fonction, args) {
         const promesse = new Promise((résoudre, rejeter) => {
-            once(this.événements, id).then((données) => {
-                const { résultat, erreur } = données[0];
-                if (erreur)
-                    rejeter(new Error(erreur));
-                else
-                    résoudre(résultat);
+            lorsque(this.événementsInternes, id).then((données) => {
+                const retour = données[0];
+                if (retour.type === "erreur")
+                    rejeter(new Error(retour.erreur));
+                else if (retour.type === "action")
+                    résoudre(retour.résultat);
             });
         });
-        this.envoyerMessage(message);
+        this.envoyerMessageÀIpa(message);
         return promesse;
     }
-    erreur({ erreur, id }) {
-        const infoErreur = { erreur, id };
-        this.événements.emit("erreur", {
-            nouvelle: infoErreur,
-            toutes: this.erreurs,
-        });
-        throw new Error(JSON.stringify(infoErreur));
+    erreur({ erreur, code, id, }) {
+        this.événements.emit("erreur", { erreur, id, code });
+        // throw new Error(JSON.stringify(infoErreur));
     }
@@ -189,2 +161,38 @@ async oublierTâche(id) {
     }
+    async souleverErreur() { }
+    async recevoirMessageDIpa(message) {
+        const { type } = message;
+        switch (type) {
+            case "suivre": {
+                const { id, données } = message;
+                if (!this.tâches[id])
+                    return;
+                const { fSuivre } = this.tâches[id];
+                fSuivre(données);
+                break;
+            }
+            case "action":
+            case "suivrePrêt":
+            case "erreur": {
+                if (message.type === "erreur" && !message.id) {
+                    this.erreur({ erreur: message.erreur, code: ERREUR_EXÉCUTION_IPA });
+                    break;
+                }
+                this.événementsInternes.emit(message.id, message);
+                break;
+            }
+            default: {
+                this.erreur({
+                    code: ERREUR_MESSAGE_INCONNU,
+                    erreur: `Type inconnu ${type} du message ${message}.`,
+                    id: message.id,
+                });
+            }
+        }
+    }
+    // Fonctions publiques
+    suivreErreurs({ f }) {
+        this.événements.on("erreur", f);
+        return () => this.événements.off("erreur", f);
+    }
 }
@@ -197,3 +205,3 @@ class Handler {
     get(obj, prop) {
-        const directes = ["événements", "erreurs"];
+        const directes = ["suivreErreurs"];
         if (directes.includes(prop)) {
@@ -200,0 +208,0 @@ return obj[prop];

dist/src/version.d.ts

@@ -1,1 +0,1 @@
-export declare const version = "1.0.2";
+export declare const version = "2.0.0";

dist/src/version.js

 // Generated by genversion.
-export const version = "1.0.2";
+export const version = "2.0.0";
 //# sourceMappingURL=version.js.map

dist/test/mandataire.spec.js

@@ -5,7 +5,7 @@ import { mandataire } from "@constl/ipa";
 import { isValidAddress } from "@orbitdb/core";
-import { générerMandataire, ClientMandatairifiable, } from "../src/mandataire.js";
+import { générerMandataire, Mandatairifiable, } from "../src/mandataire.js";
 import { isNode, isElectronMain } from "wherearewe";
 import { expect, chai, chaiAsPromised } from "aegir/chai";
 chai.use(chaiAsPromised);
-class Mandataire extends ClientMandatairifiable {
+class Mandataire extends Mandatairifiable {
     gestionnaireClient;
@@ -21,3 +21,3 @@ constructor({ opts }) {
     }
-    envoyerMessage(message) {
+    envoyerMessageÀIpa(message) {
         this.gestionnaireClient.gérerMessage(message);
@@ -24,0 +24,0 @@ }

package.json

 {
   "name": "@constl/mandataire",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Un mandataire très léger pour le client Constellation.",
@@ -23,16 +23,18 @@ "author": "Julien Jean Malard-Adam",
   "devDependencies": {
-    "@constl/ipa": "^1.0.12",
+    "@constl/ipa": "^1.0.21",
     "@constl/orbit-db-types": "^2.0.0",
     "@constl/utils-ipa": "^1.0.0",
-    "@constl/utils-tests": "^1.2.5",
-    "@orbitdb/core": "^2.0.1",
+    "@constl/utils-tests": "^1.2.6",
+    "@eslint/js": "^9.4.0",
+    "@orbitdb/core": "^2.2.0",
     "@types/mocha": "^10.0.6",
     "@types/uuid": "^9.0.8",
-    "@typescript-eslint/eslint-plugin": "^7.8.0",
-    "@typescript-eslint/parser": "^7.8.0",
-    "aegir": "^42.2.11",
+    "@typescript-eslint/eslint-plugin": "^7.12.0",
+    "@typescript-eslint/parser": "^7.12.0",
+    "aegir": "^43.0.1",
     "browserify-fs": "^1.0.0",
     "buffer": "^6.0.3",
     "crypto-browserify": "^3.12.0",
-    "eslint": "^8.57.0",
+    "electron": "^31.0.0",
+    "eslint": "^9.4.0",
     "eslint-config-prettier": "^9.1.0",
@@ -42,7 +44,9 @@ "genversion": "^3.2.0",
     "os-browserify": "^0.3.0",
-    "prettier": "^3.2.5",
+    "prettier": "^3.3.1",
     "process": "^0.11.10",
-    "rimraf": "^5.0.5",
-    "ts-patch": "^3.1.2",
+    "rimraf": "^5.0.7",
+    "ts-patch": "^3.2.0",
+    "typed-emitter": "^2.1.0",
     "typescript": "^5.4.5",
+    "typescript-eslint": "^7.12.0",
     "typescript-transform-paths": "^3.4.7",
@@ -60,3 +64,3 @@ "url": "^0.11.3",
     "couverture": "pnpm test -- --coverage",
-    "formatter": "pnpm prettier --ignore-path .gitignore --write \"**/*.+(js|ts|json)\" && pnpm eslint --ext .js,.ts src",
+    "formatter": "pnpm prettier --ignore-path .gitignore --write \"**/*.+(js|ts|json)\" && pnpm eslint src",
     "publier": "pnpm test && (git commit -a -m 'version' || true) && pnpm publish",
@@ -63,0 +67,0 @@ "versioner": "pnpm genversion  --es6 --semi src/version.ts"

src/index.ts

 export {
-  MandataireClientConstellation,
-  ClientMandatairifiable,
+  MandataireConstellation,
+  Mandatairifiable,
   générerMandataire,
@@ -5,0 +5,0 @@ } from "@/mandataire.js";

src/mandataire.ts

@@ -0,5 +1,26 @@
+import type TypedEmitter from "typed-emitter";
+import type { types } from "@constl/ipa";
+
 import { v4 as uuidv4 } from "uuid";
-import { EventEmitter, once } from "events";
+import { EventEmitter } from "events";
 
-import type { mandataire, types } from "@constl/ipa";
+import {
+  MessageActionDIpa,
+  MessageActionPourIpa,
+  MessageDIpa,
+  MessageErreurDIpa,
+  MessagePourIpa,
+  MessageRetourPourIpa,
+  MessageSuivrePourIpa,
+  MessageSuivrePrêtDIpa,
+} from "./messages.js";
+import {
+  ERREUR_EXÉCUTION_IPA,
+  ERREUR_FONCTION_MANQUANTE,
+  ERREUR_FORMAT_ARGUMENTS,
+  ERREUR_MESSAGE_INCONNU,
+  ERREUR_MULTIPLES_FONCTIONS,
+  ERREUR_PAS_UNE_FONCTION,
+} from "./codes.js";
+import { lorsque } from "./utils.js";
 
@@ -23,4 +44,16 @@ interface Tâche {
 
-export abstract class ClientMandatairifiable extends Callable {
-  événements: EventEmitter;
+export type ErreurMandataire = { code: string; erreur: string; id?: string };
+
+type ÉvénementsMandataire = {
+  message: (m: MessageDIpa) => void;
+  erreur: (e: ErreurMandataire) => void;
+};
+
+export abstract class Mandatairifiable extends Callable {
+  événements: TypedEmitter<ÉvénementsMandataire>;
+  événementsInternes: TypedEmitter<{
+    [id: string]: (
+      x: MessageActionDIpa | MessageSuivrePrêtDIpa | MessageErreurDIpa,
+    ) => void;
+  }>;
   tâches: { [key: string]: Tâche };
@@ -32,3 +65,6 @@ erreurs: { erreur: string; id?: string }[];
 
-    this.événements = new EventEmitter();
+    this.événements = new EventEmitter() as TypedEmitter<ÉvénementsMandataire>;
+    this.événementsInternes = new EventEmitter() as TypedEmitter<{
+      [id: string]: (x: unknown) => void;
+    }>;
 
@@ -38,43 +74,5 @@ this.tâches = {};
 
-    this.événements.on(
-      "message",
-      (m: mandataire.messages.MessageDeTravailleur) => {
-        const { type } = m;
-        switch (type) {
-          case "suivre": {
-            const { id, données } =
-              m as mandataire.messages.MessageSuivreDeTravailleur;
-            if (!this.tâches[id]) return;
-            const { fSuivre } = this.tâches[id];
-            fSuivre(données);
-            break;
-          }
-          case "suivrePrêt": {
-            const { id, fonctions } =
-              m as mandataire.messages.MessageSuivrePrêtDeTravailleur;
-            this.événements.emit(id, { fonctions });
-            break;
-          }
-          case "action": {
-            const { id, résultat } =
-              m as mandataire.messages.MessageActionDeTravailleur;
-            this.événements.emit(id, { résultat });
-            break;
-          }
-          case "erreur": {
-            const { erreur, id } =
-              m as mandataire.messages.MessageErreurDeTravailleur;
-            if (id) this.événements.emit(id, { erreur });
-            else this.erreur({ erreur, id });
-            break;
-          }
-          default: {
-            this.erreur({
-              erreur: `Type inconnu ${type} dans message ${m}.`,
-              id: (m as mandataire.messages.MessageDeTravailleur).id,
-            });
-          }
-        }
-      },
-    );
+    this.événements.on("message", (m) => {
+      this.recevoirMessageDIpa(m);
+    });
   }
@@ -88,2 +86,3 @@
       this.erreur({
+        code: ERREUR_FORMAT_ARGUMENTS,
         erreur: `La fonction ${fonction.join(
@@ -121,2 +120,3 @@ ".",
       this.erreur({
+        code: ERREUR_FONCTION_MANQUANTE,
         erreur:
@@ -127,2 +127,3 @@ "Aucun argument de nom " +
           fonction.join("."),
+        id,
       });
@@ -132,2 +133,3 @@ }
       this.erreur({
+        code: ERREUR_MULTIPLES_FONCTIONS,
         erreur:
@@ -142,2 +144,3 @@ "Plus d'un argument pour " +
       this.erreur({
+        code: ERREUR_PAS_UNE_FONCTION,
         erreur: "Argument " + nomArgFonction + "n'est pas une fonction : ",
@@ -148,3 +151,3 @@ id,
 
-    const message: mandataire.messages.MessageSuivrePourTravailleur = {
+    const message: MessageSuivrePourIpa = {
       type: "suivre",
@@ -158,3 +161,3 @@ id,
     const fRetour = async (fonction: string, args?: unknown[]) => {
-      const messageRetour: mandataire.messages.MessageRetourPourTravailleur = {
+      const messageRetour: MessageRetourPourIpa = {
         type: "retour",
@@ -165,3 +168,3 @@ id,
       };
-      this.envoyerMessage(messageRetour);
+      this.envoyerMessageÀIpa(messageRetour);
     };
@@ -180,25 +183,26 @@
 
-    this.envoyerMessage(message);
+    this.envoyerMessageÀIpa(message);
 
-    const { fonctions, erreur } = (await once(this.événements, id))[0] as {
-      fonctions?: string[];
-      erreur?: string;
-    };
-    if (erreur) {
-      this.erreur({ erreur, id });
+    const retour = (await lorsque(this.événementsInternes, id))[0];
+
+    if (retour.type === "erreur") {
+      this.erreur({ erreur: retour.erreur, id, code: ERREUR_EXÉCUTION_IPA });
     }
 
-    if (fonctions && fonctions[0]) {
-      const retour: { [key: string]: (...args: unknown[]) => Promise<void> } = {
-        fOublier: fOublierTâche,
-      };
-      for (const f of fonctions) {
-        retour[f] = async (...args: unknown[]) => {
-          await this.tâches[id]?.fRetour(f, args);
-        };
+    if (retour.type === "suivrePrêt") {
+      const { fonctions } = retour;
+      if (fonctions && fonctions[0]) {
+        const retour: { [key: string]: (...args: unknown[]) => Promise<void> } =
+          {
+            fOublier: fOublierTâche,
+          };
+        for (const f of fonctions) {
+          retour[f] = async (...args: unknown[]) => {
+            await this.tâches[id]?.fRetour(f, args);
+          };
+        }
+        return retour;
       }
-      return retour;
-    } else {
-      return fOublierTâche;
     }
+    return fOublierTâche;
   }
@@ -211,3 +215,3 @@
   ): Promise<T> {
-    const message: mandataire.messages.MessageActionPourTravailleur = {
+    const message: MessageActionPourIpa = {
       type: "action",
@@ -220,10 +224,10 @@ id,
     const promesse = new Promise<T>((résoudre, rejeter) => {
-      once(this.événements, id).then((données) => {
-        const { résultat, erreur } = données[0];
-        if (erreur) rejeter(new Error(erreur));
-        else résoudre(résultat);
+      lorsque(this.événementsInternes, id).then((données) => {
+        const retour = données[0];
+        if (retour.type === "erreur") rejeter(new Error(retour.erreur));
+        else if (retour.type === "action") résoudre(retour.résultat as T);
       });
     });
 
-    this.envoyerMessage(message);
+    this.envoyerMessageÀIpa(message);
 
@@ -233,9 +237,13 @@ return promesse;
 
-  erreur({ erreur, id }: { erreur: string; id?: string }): void {
-    const infoErreur = { erreur, id };
-    this.événements.emit("erreur", {
-      nouvelle: infoErreur,
-      toutes: this.erreurs,
-    });
-    throw new Error(JSON.stringify(infoErreur));
+  erreur({
+    erreur,
+    code,
+    id,
+  }: {
+    erreur: string;
+    code: string;
+    id?: string;
+  }): void {
+    this.événements.emit("erreur", { erreur, id, code });
+    // throw new Error(JSON.stringify(infoErreur));
   }
@@ -249,5 +257,41 @@
 
-  abstract envoyerMessage(
-    message: mandataire.messages.MessagePourTravailleur,
-  ): void;
+  async souleverErreur(): Promise<void> {}
+
+  abstract envoyerMessageÀIpa(message: MessagePourIpa): void;
+
+  async recevoirMessageDIpa(message: MessageDIpa): Promise<void> {
+    const { type } = message;
+    switch (type) {
+      case "suivre": {
+        const { id, données } = message;
+        if (!this.tâches[id]) return;
+        const { fSuivre } = this.tâches[id];
+        fSuivre(données);
+        break;
+      }
+      case "action":
+      case "suivrePrêt":
+      case "erreur": {
+        if (message.type === "erreur" && !message.id) {
+          this.erreur({ erreur: message.erreur, code: ERREUR_EXÉCUTION_IPA });
+          break;
+        }
+        this.événementsInternes.emit(message.id, message);
+        break;
+      }
+      default: {
+        this.erreur({
+          code: ERREUR_MESSAGE_INCONNU,
+          erreur: `Type inconnu ${type} du message ${message}.`,
+          id: (message as MessageDIpa).id,
+        });
+      }
+    }
+  }
+
+  // Fonctions publiques
+  suivreErreurs({ f }: { f: (x: ErreurMandataire) => void }) {
+    this.événements.on("erreur", f);
+    return () => this.événements.off("erreur", f);
+  }
 }
@@ -262,6 +306,6 @@
 
-  get(obj: ClientMandatairifiable, prop: string): unknown {
-    const directes = ["événements", "erreurs"];
+  get(obj: Mandatairifiable, prop: string): unknown {
+    const directes = ["suivreErreurs"];
     if (directes.includes(prop)) {
-      return obj[prop as keyof ClientMandatairifiable];
+      return obj[prop as keyof Mandatairifiable];
     } else {
@@ -275,3 +319,3 @@ const listeAtributs = [...this.listeAtributs, prop];
   apply(
-    target: ClientMandatairifiable,
+    target: Mandatairifiable,
     _thisArg: Handler,
@@ -284,13 +328,12 @@ args: [{ [key: string]: unknown }],
 
-export type MandataireClientConstellation<T> = Required<T> &
-  ClientMandatairifiable;
+export type MandataireConstellation<T> = Required<T> & Mandatairifiable;
 
 export const générerMandataire = <T>(
-  mandataireClient: ClientMandatairifiable,
-): MandataireClientConstellation<T> => {
+  mandataireClient: Mandatairifiable,
+): MandataireConstellation<T> => {
   const handler = new Handler();
-  return new Proxy<ClientMandatairifiable>(
+  return new Proxy<Mandatairifiable>(
     mandataireClient,
     handler,
-  ) as MandataireClientConstellation<T>;
+  ) as MandataireConstellation<T>;
 };

src/version.ts

 // Generated by genversion.
-export const version = "1.0.2";
+export const version = "2.0.0";

test/mandataire.spec.ts

@@ -0,1 +1,3 @@
+import type { MessageDIpa, MessagePourIpa } from "@/messages.js";
+
 import { client, types, mandataire } from "@constl/ipa";
@@ -7,4 +9,4 @@ import { faisRien } from "@constl/utils-ipa";
   générerMandataire,
-  ClientMandatairifiable,
-  MandataireClientConstellation,
+  Mandatairifiable,
+  MandataireConstellation,
 } from "@/mandataire.js";
@@ -17,3 +19,3 @@
 
-class Mandataire extends ClientMandatairifiable {
+class Mandataire extends Mandatairifiable {
   gestionnaireClient: mandataire.gestionnaireClient.GestionnaireClient;
@@ -24,4 +26,3 @@ constructor({ opts }: { opts: client.optsConstellation }) {
       new mandataire.gestionnaireClient.GestionnaireClient(
-        (m: mandataire.messages.MessageDeTravailleur) =>
-          this.événements.emit("message", m),
+        (m: MessageDIpa) => this.événements.emit("message", m),
         (e: string, idRequète?: string) =>
@@ -37,3 +38,3 @@ this.événements.emit("message", {
 
-  envoyerMessage(message: mandataire.messages.MessagePourTravailleur): void {
+  envoyerMessageÀIpa(message: MessagePourIpa): void {
     this.gestionnaireClient.gérerMessage(message);
@@ -44,3 +45,3 @@ }
 describe("Mandataire Constellation", () => {
-  let mnd: MandataireClientConstellation<client.ClientConstellation>;
+  let mnd: MandataireConstellation<client.ClientConstellation>;
   let fOublierConstellation: types.schémaFonctionOublier;
@@ -47,0 +48,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

281145

increased by5.39%

Number of package files

45

increased by36.36%

Lines of code

3475

increased by6.53%

Number of medium supply chain risk alerts

0

decreased by-100%

Worsened metrics

Dev dependency count

30

increased by15.38%

No dependency changes