@indos/bibliotheque 0.0.0-stage → 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +31 -0
- package/LICENSE +21 -0
- package/README.md +8 -2
- package/bin/page-de-l-espace.d.ts +1 -0
- package/bin/page-de-l-espace.js +29 -0
- package/modeles/partage.sql +16 -0
- package/package.json +117 -4
- package/src/app.d.ts +3 -0
- package/src/app.js +30 -0
- package/src/appel-d-ecran.d.ts +18 -0
- package/src/appel-d-ecran.js +82 -0
- package/src/appeler.d.ts +13 -0
- package/src/appeler.js +33 -0
- package/src/base-d-essai.d.ts +4 -0
- package/src/base-d-essai.js +18 -0
- package/src/base.d.ts +3 -0
- package/src/base.js +49 -0
- package/src/compte.d.ts +53 -0
- package/src/compte.js +176 -0
- package/src/deriver.d.ts +2 -0
- package/src/deriver.js +28 -0
- package/src/description-des-comptes.d.ts +50 -0
- package/src/description-des-comptes.js +4 -0
- package/src/ecran.d.ts +90 -0
- package/src/ecran.js +139 -0
- package/src/espace/appel.d.ts +10 -0
- package/src/espace/appel.js +20 -0
- package/src/espace/appels.d.ts +23 -0
- package/src/espace/appels.js +81 -0
- package/src/espace/comptes.d.ts +1 -0
- package/src/espace/comptes.js +180 -0
- package/src/espace/contexte.d.ts +8 -0
- package/src/espace/contexte.js +6 -0
- package/src/espace/coquille.d.ts +2 -0
- package/src/espace/coquille.js +76 -0
- package/src/espace/ecran.d.ts +10 -0
- package/src/espace/ecran.js +23 -0
- package/src/espace/entree-active.d.ts +2 -0
- package/src/espace/entree-active.js +21 -0
- package/src/espace/erreur.d.ts +3 -0
- package/src/espace/erreur.js +23 -0
- package/src/espace/heure.d.ts +1 -0
- package/src/espace/heure.js +14 -0
- package/src/espace/index.d.ts +12 -0
- package/src/espace/index.js +13 -0
- package/src/espace/lancer.d.ts +3 -0
- package/src/espace/lancer.js +13 -0
- package/src/espace/lien.d.ts +6 -0
- package/src/espace/lien.js +43 -0
- package/src/espace/navigation.d.ts +1 -0
- package/src/espace/navigation.js +5 -0
- package/src/espace/page.d.ts +25 -0
- package/src/espace/page.js +51 -0
- package/src/espace/pagination.d.ts +8 -0
- package/src/espace/pagination.js +19 -0
- package/src/espace/session.d.ts +37 -0
- package/src/espace/session.js +13 -0
- package/src/faux-core.d.ts +29 -0
- package/src/faux-core.js +112 -0
- package/src/fichiers.d.ts +32 -0
- package/src/fichiers.js +97 -0
- package/src/jeton.d.ts +10 -0
- package/src/jeton.js +96 -0
- package/src/liens.d.ts +10 -0
- package/src/liens.js +52 -0
- package/src/mcp.d.ts +20 -0
- package/src/mcp.js +153 -0
- package/src/page.d.ts +17 -0
- package/src/page.js +127 -0
- package/src/pagination.d.ts +1 -0
- package/src/pagination.js +4 -0
- package/src/partage.d.ts +62 -0
- package/src/partage.js +248 -0
- package/src/session.d.ts +17 -0
- package/src/session.js +124 -0
- package/src/theme.d.ts +2 -0
- package/src/theme.js +52 -0
- package/src/type-de-fichier.d.ts +6 -0
- package/src/type-de-fichier.js +115 -0
- package/src/ui/annonce.d.ts +7 -0
- package/src/ui/annonce.js +18 -0
- package/src/ui/blocs.d.ts +44 -0
- package/src/ui/blocs.js +34 -0
- package/src/ui/bouton.d.ts +7 -0
- package/src/ui/bouton.js +13 -0
- package/src/ui/cases.d.ts +19 -0
- package/src/ui/cases.js +17 -0
- package/src/ui/champ.d.ts +21 -0
- package/src/ui/champ.js +25 -0
- package/src/ui/choix.d.ts +16 -0
- package/src/ui/choix.js +11 -0
- package/src/ui/classes.d.ts +2 -0
- package/src/ui/classes.js +7 -0
- package/src/ui/confirmation.d.ts +12 -0
- package/src/ui/confirmation.js +6 -0
- package/src/ui/fenetre.d.ts +13 -0
- package/src/ui/fenetre.js +40 -0
- package/src/ui/graphiques.d.ts +44 -0
- package/src/ui/graphiques.js +128 -0
- package/src/ui/index.d.ts +18 -0
- package/src/ui/index.js +20 -0
- package/src/ui/lien.d.ts +8 -0
- package/src/ui/lien.js +10 -0
- package/src/ui/menu.d.ts +8 -0
- package/src/ui/menu.js +20 -0
- package/src/ui/panneau.d.ts +12 -0
- package/src/ui/panneau.js +17 -0
- package/src/ui/repli.d.ts +12 -0
- package/src/ui/repli.js +6 -0
- package/src/ui/suggestions.d.ts +14 -0
- package/src/ui/suggestions.js +54 -0
- package/src/ui/tableau.d.ts +18 -0
- package/src/ui/tableau.js +28 -0
- package/src/ui/theme.css +112 -0
- package/src/ui/vues.d.ts +15 -0
- package/src/ui/vues.js +7 -0
- package/src/vite.d.ts +19 -0
- package/src/vite.js +195 -0
- package/tsconfig.page.json +30 -0
package/src/compte.js
ADDED
|
@@ -0,0 +1,176 @@
|
|
|
1
|
+
import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
|
|
2
|
+
import { Refus } from './mcp.js';
|
|
3
|
+
import { traiterUnGesteDEcran } from './page.js';
|
|
4
|
+
import { creerLaSession } from './session.js';
|
|
5
|
+
// Un compte branché (docs/architecture.md, « Les règles communes ») : l'accès d'une
|
|
6
|
+
// personne à un service extérieur, comme une boîte mail, un agenda ou un kDrive. Il vit dans la
|
|
7
|
+
// base de l'app qui s'en sert, son secret chiffré ; la personne le branche, le modifie et le retire
|
|
8
|
+
// dans les réglages de l'app, sur l'écran commun des comptes, et elle seule le voit. Claude ne voit
|
|
9
|
+
// jamais son secret.
|
|
10
|
+
// Le secret d'un compte (un mot de passe, un jeton), chiffré en AES-256-GCM par une clé de l'app
|
|
11
|
+
// tirée de `CLE` (`deriver(CLE, <usage>)`) : le vecteur (12 octets), l'étiquette (16) et le
|
|
12
|
+
// chiffré, ensemble en base64. L'identifiant du compte entre dans les données authentifiées : un
|
|
13
|
+
// chiffré recopié sur un autre compte ne s'ouvre pas. La même clé maître redonne la même clé à la
|
|
14
|
+
// remontée du serveur.
|
|
15
|
+
export function chiffrer(cle, compte, texte) {
|
|
16
|
+
const vecteur = randomBytes(12);
|
|
17
|
+
const chiffreur = createCipheriv('aes-256-gcm', cle, vecteur);
|
|
18
|
+
chiffreur.setAAD(Buffer.from(compte, 'utf8'));
|
|
19
|
+
const chiffre = Buffer.concat([chiffreur.update(texte, 'utf8'), chiffreur.final()]);
|
|
20
|
+
return Buffer.concat([vecteur, chiffreur.getAuthTag(), chiffre]).toString('base64');
|
|
21
|
+
}
|
|
22
|
+
// Lève une erreur si le chiffré ne s'ouvre pas : une autre clé, un autre compte, un chiffré abîmé.
|
|
23
|
+
export function dechiffrer(cle, compte, enBase64) {
|
|
24
|
+
const octets = Buffer.from(enBase64, 'base64');
|
|
25
|
+
const dechiffreur = createDecipheriv('aes-256-gcm', cle, octets.subarray(0, 12), { authTagLength: 16 });
|
|
26
|
+
dechiffreur.setAAD(Buffer.from(compte, 'utf8'));
|
|
27
|
+
dechiffreur.setAuthTag(octets.subarray(12, 28));
|
|
28
|
+
return Buffer.concat([dechiffreur.update(octets.subarray(28)), dechiffreur.final()]).toString('utf8');
|
|
29
|
+
}
|
|
30
|
+
// Le secret que garde un compte modifié sans le retaper : celui qui est enregistré, déchiffré, mais
|
|
31
|
+
// seulement vers la même destination, pour qu'il ne parte jamais ailleurs. La destination dit où le
|
|
32
|
+
// secret part (le serveur, le port, l'identifiant), lue et mise en forme par l'app ; `enregistree`
|
|
33
|
+
// est celle du compte en base. Rien si elle a changé : la personne retape le secret. Comme
|
|
34
|
+
// `dechiffrer`, lève une erreur si le chiffré enregistré ne s'ouvre plus.
|
|
35
|
+
export function garderLeSecret(cle, compte, chiffre, destination, enregistree) {
|
|
36
|
+
if (destination.length !== enregistree.length || destination.some((valeur, i) => valeur !== enregistree[i])) {
|
|
37
|
+
return undefined;
|
|
38
|
+
}
|
|
39
|
+
return dechiffrer(cle, compte, chiffre);
|
|
40
|
+
}
|
|
41
|
+
// Les messages après un geste, par leur code (`?fait=<code>`).
|
|
42
|
+
const faitsParDefaut = {
|
|
43
|
+
branche: { titre: 'Compte branché' },
|
|
44
|
+
modifie: { titre: 'Modifications enregistrées' },
|
|
45
|
+
retire: { titre: 'Compte retiré', texte: 'Son accès est effacé de l\'OS.' },
|
|
46
|
+
};
|
|
47
|
+
// Ce qu'entraîne le retrait d'un compte, quand l'app ne le dit pas.
|
|
48
|
+
const suitesParDefaut = ['Son accès est effacé de l\'OS.', 'Rien n\'est effacé chez son fournisseur.'];
|
|
49
|
+
// L'identifiant d'un compte, un UUID.
|
|
50
|
+
const formeDUnId = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
51
|
+
// Les gestes d'écran des comptes d'une app (bibliotheque/CLAUDE.md, « Un compte branché »), que
|
|
52
|
+
// l'écran commun des comptes (`EcranDesComptes`, `@indos/bibliotheque/espace`) appelle depuis la page
|
|
53
|
+
// de l'app. Il rend `traiter(requete, reponse, chemin)`, qui sert `/espace/comptes/…` et rend faux
|
|
54
|
+
// pour un autre chemin ; `chemin` est celui de la requête, sans le chemin de l'app. Chaque geste
|
|
55
|
+
// passe par `traiterUnGesteDEcran`, avec l'origine de l'app et la session du core :
|
|
56
|
+
// - `decrire`, `{}` : les textes et les champs de l'écran ;
|
|
57
|
+
// - `lister`, `{}` : les comptes de la personne, sans la valeur d'aucun secret ;
|
|
58
|
+
// - `brancher`, `{ valeurs }` ; `modifier`, `{ id, valeurs }` ; `retirer`, `{ id }` : `{}`, ou le
|
|
59
|
+
// refus de l'app (422), son texte.
|
|
60
|
+
// Une erreur levée par un geste de l'app, ou un lien d'une autre origine, répond 500, sa cause au
|
|
61
|
+
// journal de l'app.
|
|
62
|
+
export function creerLesGestesDesComptes(options) {
|
|
63
|
+
const { textes, champs } = options;
|
|
64
|
+
const session = creerLaSession(options.adresse, options.adresseDuCore);
|
|
65
|
+
const racine = options.adresse.replace(/\/$/, '');
|
|
66
|
+
const origine = new URL(racine).origin;
|
|
67
|
+
const secrets = new Set(champs.filter((champ) => champ.genre === 'secret').map((champ) => champ.nom));
|
|
68
|
+
function decrire(personne) {
|
|
69
|
+
return {
|
|
70
|
+
titre: textes.titre,
|
|
71
|
+
presentation: textes.presentation(personne),
|
|
72
|
+
aucun: textes.aucun,
|
|
73
|
+
brancher: textes.brancher,
|
|
74
|
+
retirer: textes.retirer,
|
|
75
|
+
etapes: textes.etapes ?? [],
|
|
76
|
+
suites: textes.suites ?? suitesParDefaut,
|
|
77
|
+
faits: { ...faitsParDefaut, ...textes.faits },
|
|
78
|
+
champs: champs.map(champDecrit),
|
|
79
|
+
};
|
|
80
|
+
}
|
|
81
|
+
// Un compte de l'app, pour l'écran : ses valeurs sans aucun secret, même si l'app l'y met, et son
|
|
82
|
+
// lien rendu entier, qui ne mène qu'à l'app.
|
|
83
|
+
function compteListe(compte) {
|
|
84
|
+
const valeurs = {};
|
|
85
|
+
for (const champ of champs) {
|
|
86
|
+
const valeur = compte.valeurs[champ.nom];
|
|
87
|
+
if (!secrets.has(champ.nom) && typeof valeur === 'string') {
|
|
88
|
+
valeurs[champ.nom] = valeur;
|
|
89
|
+
}
|
|
90
|
+
}
|
|
91
|
+
let lien;
|
|
92
|
+
if (compte.lien) {
|
|
93
|
+
const cible = new URL(compte.lien.adresse, `${racine}/`);
|
|
94
|
+
if (cible.origin !== origine) {
|
|
95
|
+
throw new Error(`Le lien d'un compte mène à une page de l'app, pas à ${cible.origin}.`);
|
|
96
|
+
}
|
|
97
|
+
lien = { texte: compte.lien.texte, adresse: cible.href };
|
|
98
|
+
}
|
|
99
|
+
return {
|
|
100
|
+
id: compte.id,
|
|
101
|
+
nom: compte.nom,
|
|
102
|
+
...(compte.detail ? { detail: compte.detail } : {}),
|
|
103
|
+
etats: compte.etats ?? [],
|
|
104
|
+
valeurs,
|
|
105
|
+
...(lien ? { lien } : {}),
|
|
106
|
+
};
|
|
107
|
+
}
|
|
108
|
+
// Les valeurs envoyées, une par champ : un texte, vide s'il manque ou n'en est pas un ; une case
|
|
109
|
+
// vaut `oui` ou vide. Un nom inconnu est ignoré.
|
|
110
|
+
function valeursDe(corps) {
|
|
111
|
+
const envoyees = typeof corps.valeurs === 'object' && corps.valeurs !== null ? corps.valeurs : {};
|
|
112
|
+
return Object.fromEntries(champs.map((champ) => {
|
|
113
|
+
const valeur = Object.hasOwn(envoyees, champ.nom) && typeof envoyees[champ.nom] === 'string' ? envoyees[champ.nom] : '';
|
|
114
|
+
return [champ.nom, champ.genre === 'case' ? (valeur === 'oui' ? 'oui' : '') : valeur];
|
|
115
|
+
}));
|
|
116
|
+
}
|
|
117
|
+
function idDe(corps) {
|
|
118
|
+
if (typeof corps.id !== 'string' || !formeDUnId.test(corps.id)) {
|
|
119
|
+
throw new Refus('Ce compte n\'existe pas.');
|
|
120
|
+
}
|
|
121
|
+
return corps.id;
|
|
122
|
+
}
|
|
123
|
+
// Ce que l'app rend pour refuser des valeurs devient le refus du geste.
|
|
124
|
+
function refuserSi(erreur) {
|
|
125
|
+
if (erreur) {
|
|
126
|
+
throw new Refus(erreur);
|
|
127
|
+
}
|
|
128
|
+
}
|
|
129
|
+
const gestes = {
|
|
130
|
+
async decrire(personne) {
|
|
131
|
+
return decrire(personne);
|
|
132
|
+
},
|
|
133
|
+
async lister(personne) {
|
|
134
|
+
return { comptes: (await options.comptesDe(personne)).map(compteListe) };
|
|
135
|
+
},
|
|
136
|
+
async brancher(personne, corps) {
|
|
137
|
+
refuserSi(await options.brancher(personne, valeursDe(corps)));
|
|
138
|
+
},
|
|
139
|
+
async modifier(personne, corps) {
|
|
140
|
+
const id = idDe(corps);
|
|
141
|
+
refuserSi(await options.modifier(personne, id, valeursDe(corps)));
|
|
142
|
+
},
|
|
143
|
+
async retirer(personne, corps) {
|
|
144
|
+
await options.retirer(personne, idDe(corps));
|
|
145
|
+
},
|
|
146
|
+
};
|
|
147
|
+
return async function traiter(requete, reponse, chemin) {
|
|
148
|
+
const [, nom] = /^\/espace\/comptes\/([a-z]+)$/.exec(chemin.split('?')[0]) ?? [];
|
|
149
|
+
const geste = nom && Object.hasOwn(gestes, nom) ? gestes[nom] : undefined;
|
|
150
|
+
if (!geste) {
|
|
151
|
+
return false;
|
|
152
|
+
}
|
|
153
|
+
await traiterUnGesteDEcran(requete, reponse, {
|
|
154
|
+
origine,
|
|
155
|
+
personneDe: session.personneDuGeste,
|
|
156
|
+
executer: (personne, corps) => geste(personne, corps),
|
|
157
|
+
});
|
|
158
|
+
return true;
|
|
159
|
+
};
|
|
160
|
+
}
|
|
161
|
+
// Un champ, tel que `decrire` le rend.
|
|
162
|
+
function champDecrit(champ) {
|
|
163
|
+
const genre = champ.genre ?? 'texte';
|
|
164
|
+
return {
|
|
165
|
+
nom: champ.nom,
|
|
166
|
+
libelle: champ.libelle,
|
|
167
|
+
genre,
|
|
168
|
+
requis: champ.requis === true,
|
|
169
|
+
avecLeSuivant: champ.avecLeSuivant === true,
|
|
170
|
+
fixe: champ.fixe === true || genre === 'nombre' || genre === 'identifiant',
|
|
171
|
+
...(champ.defaut !== undefined ? { defaut: champ.defaut } : {}),
|
|
172
|
+
...(champ.exemple !== undefined ? { exemple: champ.exemple } : {}),
|
|
173
|
+
...(champ.aide !== undefined ? { aide: champ.aide } : {}),
|
|
174
|
+
...(champ.groupe !== undefined ? { groupe: champ.groupe } : {}),
|
|
175
|
+
};
|
|
176
|
+
}
|
package/src/deriver.d.ts
ADDED
package/src/deriver.js
ADDED
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
import { hkdfSync } from 'node:crypto';
|
|
2
|
+
// Tire une clé de 32 octets d'une autre, pour un contexte : HKDF-SHA256, sans sel, le contexte
|
|
3
|
+
// pour info. C'est la dérivation du kit (`courrier/1` depuis la clé maître) et celle d'une app
|
|
4
|
+
// qui tire ses sous-clés de la sienne (`jeton`, `lien/telechargement`).
|
|
5
|
+
export function deriver(cle, contexte) {
|
|
6
|
+
if (cle.length < 32) {
|
|
7
|
+
throw new Error('La clé à dériver doit faire au moins 32 octets.');
|
|
8
|
+
}
|
|
9
|
+
return Buffer.from(hkdfSync('sha256', cle, Buffer.alloc(0), contexte, 32));
|
|
10
|
+
}
|
|
11
|
+
// Lit une clé que le kit passe en base64 dans une variable d'environnement : 32 octets
|
|
12
|
+
// exactement, la taille d'une clé dérivée.
|
|
13
|
+
export function lireLaCle(nom) {
|
|
14
|
+
const valeur = process.env[nom];
|
|
15
|
+
if (!valeur) {
|
|
16
|
+
throw new Error(`La variable ${nom} manque : la clé de l'app vient du kit.`);
|
|
17
|
+
}
|
|
18
|
+
// Node ignore sans rien dire un caractère étranger au base64 : une clé mal recopiée
|
|
19
|
+
// donnerait d'autres sous-clés, et les données chiffrées ne se reliraient plus.
|
|
20
|
+
const cle = Buffer.from(valeur, 'base64');
|
|
21
|
+
if (cle.toString('base64') !== valeur.trim()) {
|
|
22
|
+
throw new Error(`La variable ${nom} n'est pas du base64 standard, avec son remplissage.`);
|
|
23
|
+
}
|
|
24
|
+
if (cle.length !== 32) {
|
|
25
|
+
throw new Error(`La variable ${nom} doit porter 32 octets en base64, elle en porte ${cle.length}.`);
|
|
26
|
+
}
|
|
27
|
+
return cle;
|
|
28
|
+
}
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
export type GenreDUnChamp = 'texte' | 'email' | 'nombre' | 'identifiant' | 'secret' | 'paragraphe' | 'case';
|
|
2
|
+
export type EtapeDecrite = string | {
|
|
3
|
+
texte: string;
|
|
4
|
+
adresse: string;
|
|
5
|
+
};
|
|
6
|
+
export type FaitDecrit = {
|
|
7
|
+
titre: string;
|
|
8
|
+
texte?: string;
|
|
9
|
+
};
|
|
10
|
+
export type ChampDecrit = {
|
|
11
|
+
nom: string;
|
|
12
|
+
libelle: string;
|
|
13
|
+
genre: GenreDUnChamp;
|
|
14
|
+
requis: boolean;
|
|
15
|
+
avecLeSuivant: boolean;
|
|
16
|
+
fixe: boolean;
|
|
17
|
+
defaut?: string;
|
|
18
|
+
exemple?: string;
|
|
19
|
+
aide?: string;
|
|
20
|
+
groupe?: string;
|
|
21
|
+
};
|
|
22
|
+
export type DescriptionDesComptes = {
|
|
23
|
+
titre: string;
|
|
24
|
+
presentation: string;
|
|
25
|
+
aucun: string;
|
|
26
|
+
brancher: string;
|
|
27
|
+
retirer: string;
|
|
28
|
+
etapes: EtapeDecrite[];
|
|
29
|
+
suites: string[];
|
|
30
|
+
faits: Record<string, FaitDecrit>;
|
|
31
|
+
champs: ChampDecrit[];
|
|
32
|
+
};
|
|
33
|
+
export type EtatDUnCompte = {
|
|
34
|
+
texte: string;
|
|
35
|
+
sorte?: 'active' | 'erreur';
|
|
36
|
+
};
|
|
37
|
+
export type CompteListe = {
|
|
38
|
+
id: string;
|
|
39
|
+
nom: string;
|
|
40
|
+
detail?: string;
|
|
41
|
+
etats: EtatDUnCompte[];
|
|
42
|
+
valeurs: Record<string, string>;
|
|
43
|
+
lien?: {
|
|
44
|
+
texte: string;
|
|
45
|
+
adresse: string;
|
|
46
|
+
};
|
|
47
|
+
};
|
|
48
|
+
export type ListeDesComptes = {
|
|
49
|
+
comptes: CompteListe[];
|
|
50
|
+
};
|
|
@@ -0,0 +1,4 @@
|
|
|
1
|
+
// Le contrat des gestes des comptes (`creerLesGestesDesComptes`, `@indos/bibliotheque/compte`) et
|
|
2
|
+
// de l'écran qui les appelle (`EcranDesComptes`, `@indos/bibliotheque/espace`) : ce que rendent
|
|
3
|
+
// `decrire` et `lister`. Des types seuls, sans rien de Node ni du navigateur, pour les deux.
|
|
4
|
+
export {};
|
package/src/ecran.d.ts
ADDED
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
import type { IncomingMessage, ServerResponse } from 'node:http';
|
|
2
|
+
export declare function echapper(texte: string): string;
|
|
3
|
+
export type EcranDeLaConsole = {
|
|
4
|
+
nom: string;
|
|
5
|
+
titre: string;
|
|
6
|
+
chemin: string;
|
|
7
|
+
};
|
|
8
|
+
export type AppDeLaConsole = {
|
|
9
|
+
nom: string;
|
|
10
|
+
titre: string;
|
|
11
|
+
lien: string;
|
|
12
|
+
reglages: boolean;
|
|
13
|
+
ecrans: EcranDeLaConsole[];
|
|
14
|
+
};
|
|
15
|
+
export type EntreeDeLaBarre = {
|
|
16
|
+
titre: string;
|
|
17
|
+
chemin: string;
|
|
18
|
+
app: string;
|
|
19
|
+
};
|
|
20
|
+
export type ThemeDeLaConsole = {
|
|
21
|
+
nom: string;
|
|
22
|
+
logo: boolean;
|
|
23
|
+
};
|
|
24
|
+
export type PersonneDeLEspace = {
|
|
25
|
+
nom: string;
|
|
26
|
+
email: string;
|
|
27
|
+
proprietaire: boolean;
|
|
28
|
+
apps: AppDeLaConsole[];
|
|
29
|
+
barre: EntreeDeLaBarre[];
|
|
30
|
+
theme: ThemeDeLaConsole;
|
|
31
|
+
};
|
|
32
|
+
export type Message = {
|
|
33
|
+
titre: string;
|
|
34
|
+
texte?: string;
|
|
35
|
+
erreur?: boolean;
|
|
36
|
+
};
|
|
37
|
+
export declare const entetesDUnePage: {
|
|
38
|
+
'content-type': string;
|
|
39
|
+
'cache-control': string;
|
|
40
|
+
'content-security-policy': string;
|
|
41
|
+
'referrer-policy': string;
|
|
42
|
+
};
|
|
43
|
+
export declare function envoyerLaPage(reponse: ServerResponse, statut: number, html: string): void;
|
|
44
|
+
export declare function entetesDeLEspace(cadre?: string): {
|
|
45
|
+
'content-type': string;
|
|
46
|
+
'cache-control': string;
|
|
47
|
+
'referrer-policy': string;
|
|
48
|
+
'content-security-policy': string;
|
|
49
|
+
};
|
|
50
|
+
export declare function lireLeFormulaire(requete: IncomingMessage): Promise<URLSearchParams>;
|
|
51
|
+
export declare function rediriger(reponse: ServerResponse, adresse: string): void;
|
|
52
|
+
export declare function messageDuGeste(requete: IncomingMessage, messages: Record<string, Message>): Message | undefined;
|
|
53
|
+
export type OptionsDeLaPageDAuth = {
|
|
54
|
+
theme?: ThemeDeLaConsole;
|
|
55
|
+
titre: string;
|
|
56
|
+
onglet?: string;
|
|
57
|
+
sousTitre?: string;
|
|
58
|
+
message?: Message;
|
|
59
|
+
corps: string;
|
|
60
|
+
signature?: string;
|
|
61
|
+
};
|
|
62
|
+
export declare function pageDAuth(options: OptionsDeLaPageDAuth): string;
|
|
63
|
+
export declare function pageSimple(titre: string, texte: string): string;
|
|
64
|
+
export declare function message({ titre, texte, erreur }: Message): string;
|
|
65
|
+
export type OptionsDUnChamp = {
|
|
66
|
+
id: string;
|
|
67
|
+
libelle: string;
|
|
68
|
+
saisie: string;
|
|
69
|
+
facultatif?: boolean;
|
|
70
|
+
aide?: string;
|
|
71
|
+
erreur?: string;
|
|
72
|
+
};
|
|
73
|
+
export declare function champ(options: OptionsDUnChamp): string;
|
|
74
|
+
export declare function etiquette(texte: string, sorte?: 'active' | 'erreur'): string;
|
|
75
|
+
export type Ligne = {
|
|
76
|
+
nom: string;
|
|
77
|
+
texte?: string;
|
|
78
|
+
fin?: string;
|
|
79
|
+
lien?: string;
|
|
80
|
+
};
|
|
81
|
+
export declare function lignes(liste: Ligne[]): string;
|
|
82
|
+
export declare function creerLaRacine(options: {
|
|
83
|
+
adresse: string;
|
|
84
|
+
manifeste: {
|
|
85
|
+
ecrans?: {
|
|
86
|
+
nom: string;
|
|
87
|
+
}[];
|
|
88
|
+
reglages?: boolean;
|
|
89
|
+
};
|
|
90
|
+
}): (requete: IncomingMessage, reponse: ServerResponse, chemin: string) => Promise<boolean>;
|
package/src/ecran.js
ADDED
|
@@ -0,0 +1,139 @@
|
|
|
1
|
+
// Les pages rendues par le serveur, sans script (docs/architecture.md, « L'espace et les
|
|
2
|
+
// réglages ») : la page d'auth, celles du core (la connexion, le consentement, le mot de passe), et
|
|
3
|
+
// la page simple, une page introuvable ou une erreur, du core comme d'une app. La structure est
|
|
4
|
+
// écrite ici, une fois ; le style vient du core, à la racine du même domaine (`/theme/variables.css`,
|
|
5
|
+
// `/theme/console.css`), dont les classes sont un contrat. Un paramètre de texte est échappé ; un
|
|
6
|
+
// paramètre de HTML (`corps`, `saisie`, le `texte` et la `fin` d'une ligne) l'est par l'appelant.
|
|
7
|
+
export function echapper(texte) {
|
|
8
|
+
return texte.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
|
|
9
|
+
}
|
|
10
|
+
// Les en-têtes d'une page d'auth et d'une page simple : aucun script ne s'exécute, aucune
|
|
11
|
+
// page ne s'affiche dans le cadre d'un autre site, rien ne se garde en cache. Sans `form-action`,
|
|
12
|
+
// que Chrome applique aux redirections qui suivent un formulaire : la connexion et le consentement
|
|
13
|
+
// repartent vers claude.ai. `strict-origin-when-cross-origin`, pour qu'un formulaire parte avec
|
|
14
|
+
// son origine.
|
|
15
|
+
export const entetesDUnePage = {
|
|
16
|
+
'content-type': 'text/html; charset=utf-8',
|
|
17
|
+
'cache-control': 'no-store',
|
|
18
|
+
'content-security-policy': 'default-src \'none\'; script-src \'none\'; style-src \'self\' \'unsafe-inline\'; img-src \'self\' data:; font-src \'self\'; frame-ancestors \'none\'; base-uri \'none\'',
|
|
19
|
+
'referrer-policy': 'strict-origin-when-cross-origin',
|
|
20
|
+
};
|
|
21
|
+
export function envoyerLaPage(reponse, statut, html) {
|
|
22
|
+
reponse.writeHead(statut, entetesDUnePage);
|
|
23
|
+
reponse.end(html);
|
|
24
|
+
}
|
|
25
|
+
// Les en-têtes de la page de l'espace en React (`servirLaPage`, `@indos/bibliotheque/page`) : les
|
|
26
|
+
// scripts de sa pièce seule, servis de la même origine, aucun en ligne, et ses appels à sa pièce
|
|
27
|
+
// (`connect-src 'self'`). Une page qui encadre quelque chose ajoute sa directive : `cadre` en est la
|
|
28
|
+
// source (`https://pages.exemple.ch`).
|
|
29
|
+
export function entetesDeLEspace(cadre) {
|
|
30
|
+
if (cadre !== undefined && !/^[^\s;,]+$/.test(cadre)) {
|
|
31
|
+
throw new Error(`La source d'un cadre est une seule source, sans espace ni point-virgule : ${JSON.stringify(cadre)}.`);
|
|
32
|
+
}
|
|
33
|
+
const politique = 'default-src \'none\'; script-src \'self\'; style-src \'self\' \'unsafe-inline\'; img-src \'self\' data:; font-src \'self\'; connect-src \'self\'; frame-ancestors \'none\'; base-uri \'none\'';
|
|
34
|
+
return { ...entetesDUnePage, 'content-security-policy': cadre ? `${politique}; frame-src ${cadre}` : politique };
|
|
35
|
+
}
|
|
36
|
+
// Un formulaire envoyé en application/x-www-form-urlencoded, de 64 Kio au plus.
|
|
37
|
+
export async function lireLeFormulaire(requete) {
|
|
38
|
+
const morceaux = [];
|
|
39
|
+
let taille = 0;
|
|
40
|
+
for await (const morceau of requete) {
|
|
41
|
+
taille += morceau.length;
|
|
42
|
+
if (taille > 65536) {
|
|
43
|
+
throw new Error('Formulaire trop long.');
|
|
44
|
+
}
|
|
45
|
+
morceaux.push(morceau);
|
|
46
|
+
}
|
|
47
|
+
return new URLSearchParams(Buffer.concat(morceaux).toString('utf8'));
|
|
48
|
+
}
|
|
49
|
+
// Après un formulaire accepté, la page suivante : le navigateur la demande en GET. Le message du
|
|
50
|
+
// geste y suit par un code fixe (`?fait=<code>`), que la page traduit par `messageDuGeste`.
|
|
51
|
+
export function rediriger(reponse, adresse) {
|
|
52
|
+
reponse.writeHead(303, { location: adresse });
|
|
53
|
+
reponse.end();
|
|
54
|
+
}
|
|
55
|
+
// Le message du geste qui vient d'être fait : le code `fait` de l'adresse, traduit par la table de
|
|
56
|
+
// la page. Un code inconnu ne montre rien : aucun texte ne vient de l'adresse.
|
|
57
|
+
export function messageDuGeste(requete, messages) {
|
|
58
|
+
const code = new URL(requete.url ?? '/', 'http://console').searchParams.get('fait');
|
|
59
|
+
return code && Object.hasOwn(messages, code) ? messages[code] : undefined;
|
|
60
|
+
}
|
|
61
|
+
export function pageDAuth(options) {
|
|
62
|
+
const { theme } = options;
|
|
63
|
+
return `${tete(options.onglet ?? options.titre, theme)}
|
|
64
|
+
<main class="auth">
|
|
65
|
+
${theme ? `<div class="marque">${logoDe(theme)}<span class="nom">${echapper(theme.nom)}</span></div>\n` : ''}<div class="carte">
|
|
66
|
+
<h1>${echapper(options.titre)}</h1>
|
|
67
|
+
${options.sousTitre ? `<p class="sous-titre">${echapper(options.sousTitre)}</p>\n` : ''}${options.message ? `${message(options.message)}\n` : ''}${options.corps}
|
|
68
|
+
</div>
|
|
69
|
+
${options.signature ? `<div class="signature">${echapper(options.signature)}</div>\n` : ''}</main>
|
|
70
|
+
</body>
|
|
71
|
+
</html>`;
|
|
72
|
+
}
|
|
73
|
+
// Une page qui ne sait pas qui est connecté : une erreur, une page introuvable, un formulaire refusé.
|
|
74
|
+
export function pageSimple(titre, texte) {
|
|
75
|
+
return pageDAuth({ titre, sousTitre: texte, corps: '<a class="lien-secondaire" href="/">Revenir à l\'accueil</a>' });
|
|
76
|
+
}
|
|
77
|
+
// La tête de la page : la feuille du thème et celle du core ; le logo en favicon.
|
|
78
|
+
function tete(onglet, theme) {
|
|
79
|
+
return `<!doctype html>
|
|
80
|
+
<html lang="fr">
|
|
81
|
+
<head>
|
|
82
|
+
<meta charset="utf-8">
|
|
83
|
+
<meta name="viewport" content="width=device-width, initial-scale=1">
|
|
84
|
+
<title>${echapper(theme ? `${onglet} · ${theme.nom}` : onglet)}</title>
|
|
85
|
+
<link rel="stylesheet" href="/theme/variables.css">
|
|
86
|
+
<link rel="stylesheet" href="/theme/console.css">
|
|
87
|
+
${theme?.logo ? '<link rel="icon" href="/theme/logo.svg" type="image/svg+xml">\n' : ''}</head>
|
|
88
|
+
<body class="console">`;
|
|
89
|
+
}
|
|
90
|
+
// Le logo de l'OS sur sa pastille, ou l'initiale de son nom quand il n'a pas de logo.
|
|
91
|
+
function logoDe(theme) {
|
|
92
|
+
if (theme.logo) {
|
|
93
|
+
return '<span class="logo"><img alt="" src="/theme/logo.svg"></span>';
|
|
94
|
+
}
|
|
95
|
+
const [initiale = ''] = theme.nom.trim();
|
|
96
|
+
return `<span class="logo" aria-hidden="true">${echapper(initiale.toLocaleUpperCase('fr'))}</span>`;
|
|
97
|
+
}
|
|
98
|
+
// Les briques d'une page.
|
|
99
|
+
// Le message après un geste, en tête de la carte.
|
|
100
|
+
export function message({ titre, texte, erreur }) {
|
|
101
|
+
return `<div class="message${erreur ? ' erreur' : ''}" role="${erreur ? 'alert' : 'status'}"><span class="signe" aria-hidden="true">${erreur ? '!' : '✓'}</span><span class="titre">${echapper(titre)}</span>${texte ? `<span class="texte">${echapper(texte)}</span>` : ''}</div>`;
|
|
102
|
+
}
|
|
103
|
+
export function champ(options) {
|
|
104
|
+
const aide = options.erreur ?? options.aide;
|
|
105
|
+
return `<div class="champ${options.erreur ? ' en-erreur' : ''}">
|
|
106
|
+
<label for="${echapper(options.id)}">${echapper(options.libelle)}${options.facultatif ? ' <span class="facultatif">facultatif</span>' : ''}</label>
|
|
107
|
+
${options.saisie}
|
|
108
|
+
${aide ? `<p class="aide" id="${echapper(options.id)}-aide">${echapper(aide)}</p>\n` : ''}</div>`;
|
|
109
|
+
}
|
|
110
|
+
// Un état dit par un mot : `active` (en marche, l'accent), `erreur`, ou neutre.
|
|
111
|
+
export function etiquette(texte, sorte) {
|
|
112
|
+
return `<span class="etiquette${sorte ? ` ${sorte}` : ''}">${echapper(texte)}</span>`;
|
|
113
|
+
}
|
|
114
|
+
export function lignes(liste) {
|
|
115
|
+
return `<div class="lignes">\n${liste.map((ligne) => {
|
|
116
|
+
const contenu = `<span class="nom">${echapper(ligne.nom)}</span>${ligne.texte ? `<span class="texte">${ligne.texte}</span>` : ''}${ligne.fin ? `<span class="fin">${ligne.fin}</span>` : ''}`;
|
|
117
|
+
return ligne.lien ? `<a class="ligne" href="${echapper(ligne.lien)}">${contenu}</a>` : `<div class="ligne">${contenu}</div>`;
|
|
118
|
+
}).join('\n')}\n</div>`;
|
|
119
|
+
}
|
|
120
|
+
// La racine d'une app (`GET /` sous son adresse) : son premier écran, sinon ses réglages, d'après
|
|
121
|
+
// son manifeste ; sinon une page simple en 404. Il rend `traiter(requete, reponse, chemin)`, qui
|
|
122
|
+
// sert `GET /` et rend faux pour une autre route.
|
|
123
|
+
export function creerLaRacine(options) {
|
|
124
|
+
const racine = options.adresse.replace(/\/$/, '');
|
|
125
|
+
const [premier] = options.manifeste.ecrans ?? [];
|
|
126
|
+
const cible = premier ? `${racine}/${premier.nom}` : options.manifeste.reglages ? `${racine}/reglages` : undefined;
|
|
127
|
+
return async function traiter(requete, reponse, chemin) {
|
|
128
|
+
if (chemin !== '/' || (requete.method !== 'GET' && requete.method !== 'HEAD')) {
|
|
129
|
+
return false;
|
|
130
|
+
}
|
|
131
|
+
if (cible) {
|
|
132
|
+
rediriger(reponse, cible);
|
|
133
|
+
}
|
|
134
|
+
else {
|
|
135
|
+
envoyerLaPage(reponse, 404, pageSimple('Rien à voir ici', 'Cette app n\'a pas de page : Claude s\'en sert depuis claude.ai, avec vos droits.'));
|
|
136
|
+
}
|
|
137
|
+
return true;
|
|
138
|
+
};
|
|
139
|
+
}
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
import { type UseMutationResult } from '@tanstack/react-query';
|
|
2
|
+
import { type SorteDeBouton } from '../ui/bouton.tsx';
|
|
3
|
+
import { type ResultatDUnOutil } from './appels.ts';
|
|
4
|
+
export type Appel = UseMutationResult<ResultatDUnOutil, Error, Record<string, unknown>>;
|
|
5
|
+
export declare function useAppel(outil: string): Appel;
|
|
6
|
+
export declare function RefusDUnAppel({ appel, verbe, sorte }: {
|
|
7
|
+
appel: Pick<UseMutationResult<unknown, Error, Record<string, unknown>>, 'error' | 'variables' | 'mutate' | 'isPending'>;
|
|
8
|
+
verbe?: string;
|
|
9
|
+
sorte?: SorteDeBouton;
|
|
10
|
+
}): import("react").JSX.Element | null;
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
|
|
2
|
+
import { useMutation } from '@tanstack/react-query';
|
|
3
|
+
import { Message } from '../ui/blocs.js';
|
|
4
|
+
import { Bouton } from '../ui/bouton.js';
|
|
5
|
+
import { appeler, ErreurDUnAppel } from './appels.js';
|
|
6
|
+
export function useAppel(outil) {
|
|
7
|
+
return useMutation({ mutationFn: (arguments_) => appeler(outil, arguments_) });
|
|
8
|
+
}
|
|
9
|
+
// Le refus d'un appel ou d'un geste, montré mot pour mot. `verbe` est pour un outil qui prend
|
|
10
|
+
// `confirmer` : sous son refus, un bouton qui le rappelle avec les mêmes arguments et
|
|
11
|
+
// `confirmer: true`. L'accord de la personne est ce clic. `sorte` est celle du bouton, `principal`
|
|
12
|
+
// par défaut, `detruit` pour un geste qui détruit.
|
|
13
|
+
export function RefusDUnAppel({ appel, verbe, sorte }) {
|
|
14
|
+
const { error: erreur } = appel;
|
|
15
|
+
if (!erreur) {
|
|
16
|
+
return null;
|
|
17
|
+
}
|
|
18
|
+
const aConfirmer = Boolean(verbe) && erreur instanceof ErreurDUnAppel && erreur.refus;
|
|
19
|
+
return (_jsxs("div", { className: "my-4", children: [_jsx(Message, { erreur: true, titre: erreur.message, className: aConfirmer ? 'mb-3' : 'mb-0' }), aConfirmer && (_jsx(Bouton, { type: "button", sorte: sorte, disabled: appel.isPending, onClick: () => appel.mutate({ ...appel.variables, confirmer: true }), children: verbe }))] }));
|
|
20
|
+
}
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
export type ResultatDUnOutil = {
|
|
2
|
+
content: {
|
|
3
|
+
type: string;
|
|
4
|
+
text?: string;
|
|
5
|
+
}[];
|
|
6
|
+
isError?: boolean;
|
|
7
|
+
_meta?: Record<string, unknown>;
|
|
8
|
+
};
|
|
9
|
+
export declare class ErreurDUnAppel extends Error {
|
|
10
|
+
statut: number;
|
|
11
|
+
constructor(statut: number, message: string);
|
|
12
|
+
get refus(): boolean;
|
|
13
|
+
}
|
|
14
|
+
export declare function poserLaBase(baseDeLaPage: string): void;
|
|
15
|
+
export declare function baseDeLaPage(): string;
|
|
16
|
+
export declare function allerALaConnexion(): void;
|
|
17
|
+
export declare function texteDe(resultat: ResultatDUnOutil): string;
|
|
18
|
+
export declare function demander<T>(chemin: string, options?: {
|
|
19
|
+
methode?: 'GET' | 'POST';
|
|
20
|
+
corps?: unknown;
|
|
21
|
+
}): Promise<T>;
|
|
22
|
+
export declare function faireUnGeste<T = Record<string, unknown>>(chemin: string, corps?: Record<string, unknown>): Promise<T>;
|
|
23
|
+
export declare function appeler(outil: string, arguments_?: Record<string, unknown>): Promise<ResultatDUnOutil>;
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
import { allerA } from './navigation.js';
|
|
2
|
+
// Un appel qui n'a pas abouti : son statut et le texte à montrer, mot pour mot. `refus` dit un
|
|
3
|
+
// refus de la pièce (422), que la personne peut lever, comme l'accord qui manque.
|
|
4
|
+
export class ErreurDUnAppel extends Error {
|
|
5
|
+
statut;
|
|
6
|
+
constructor(statut, message) {
|
|
7
|
+
super(message);
|
|
8
|
+
this.name = 'ErreurDUnAppel';
|
|
9
|
+
this.statut = statut;
|
|
10
|
+
}
|
|
11
|
+
get refus() {
|
|
12
|
+
return this.statut === 422;
|
|
13
|
+
}
|
|
14
|
+
}
|
|
15
|
+
// La base de la page (`/` pour le core, `/<app>/` pour une app), que pose la page à son lancement.
|
|
16
|
+
let base = '/';
|
|
17
|
+
export function poserLaBase(baseDeLaPage) {
|
|
18
|
+
base = baseDeLaPage;
|
|
19
|
+
}
|
|
20
|
+
export function baseDeLaPage() {
|
|
21
|
+
return base;
|
|
22
|
+
}
|
|
23
|
+
// La connexion du core, par une vraie navigation, qui ramène ensuite à l'adresse entière de la
|
|
24
|
+
// page, sa recherche comprise.
|
|
25
|
+
export function allerALaConnexion() {
|
|
26
|
+
const { origin, pathname, search } = window.location;
|
|
27
|
+
allerA(`/connexion?retour=${encodeURIComponent(`${origin}${pathname}${search}`)}`);
|
|
28
|
+
}
|
|
29
|
+
// Le texte d'un résultat d'outil, ses parties de texte mises bout à bout.
|
|
30
|
+
export function texteDe(resultat) {
|
|
31
|
+
return resultat.content.flatMap((partie) => (partie.type === 'text' && partie.text ? [partie.text] : [])).join('\n');
|
|
32
|
+
}
|
|
33
|
+
// Un appel en JSON à la même origine. Un 401 mène à la connexion ; une autre réponse que 200 lève
|
|
34
|
+
// `ErreurDUnAppel`, avec l'`erreur` rendue, ou le texte du résultat d'un outil refusé.
|
|
35
|
+
export async function demander(chemin, options = {}) {
|
|
36
|
+
const methode = options.methode ?? 'POST';
|
|
37
|
+
let reponse;
|
|
38
|
+
try {
|
|
39
|
+
reponse = await fetch(chemin, {
|
|
40
|
+
method: methode,
|
|
41
|
+
credentials: 'same-origin',
|
|
42
|
+
headers: methode === 'POST' ? { accept: 'application/json', 'content-type': 'application/json' } : { accept: 'application/json' },
|
|
43
|
+
body: methode === 'POST' ? JSON.stringify(options.corps ?? {}) : undefined,
|
|
44
|
+
});
|
|
45
|
+
}
|
|
46
|
+
catch {
|
|
47
|
+
throw new ErreurDUnAppel(0, 'Le serveur ne répond pas. Vérifier la connexion, puis réessayer.');
|
|
48
|
+
}
|
|
49
|
+
if (reponse.status === 401) {
|
|
50
|
+
allerALaConnexion();
|
|
51
|
+
return new Promise(() => { });
|
|
52
|
+
}
|
|
53
|
+
const corps = await reponse.json().catch(() => undefined);
|
|
54
|
+
if (!reponse.ok) {
|
|
55
|
+
throw new ErreurDUnAppel(reponse.status, texteDeLErreur(corps) ?? `Le serveur a répondu ${reponse.status}.`);
|
|
56
|
+
}
|
|
57
|
+
return corps;
|
|
58
|
+
}
|
|
59
|
+
function texteDeLErreur(corps) {
|
|
60
|
+
if (typeof corps !== 'object' || corps === null) {
|
|
61
|
+
return undefined;
|
|
62
|
+
}
|
|
63
|
+
if (typeof corps.erreur === 'string') {
|
|
64
|
+
return corps.erreur;
|
|
65
|
+
}
|
|
66
|
+
if (Array.isArray(corps.content)) {
|
|
67
|
+
return texteDe(corps) || undefined;
|
|
68
|
+
}
|
|
69
|
+
return undefined;
|
|
70
|
+
}
|
|
71
|
+
// Un geste d'écran du core ou d'une app (`traiterUnGesteDEcran`) : `POST <chemin>`, son corps en
|
|
72
|
+
// JSON. 200 : son JSON ; un refus (422) lève `ErreurDUnAppel`, son `erreur` mot pour mot.
|
|
73
|
+
export function faireUnGeste(chemin, corps = {}) {
|
|
74
|
+
return demander(chemin, { corps });
|
|
75
|
+
}
|
|
76
|
+
// L'appel d'un outil de l'app par son écran, les mêmes outils que Claude : `POST <base>outils/<outil>`.
|
|
77
|
+
// 200 : le résultat MCP, dont l'écran montre le texte (`texteDe`) ; un refus (422) lève
|
|
78
|
+
// `ErreurDUnAppel`, son texte mot pour mot, comme les autres refus.
|
|
79
|
+
export function appeler(outil, arguments_ = {}) {
|
|
80
|
+
return demander(`${base}outils/${encodeURIComponent(outil)}`, { corps: arguments_ });
|
|
81
|
+
}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export declare function EcranDesComptes(): import("react").JSX.Element;
|