@indos/bibliotheque 1.11.0 → 1.13.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 +36 -0
- package/package.json +37 -2
- package/src/app.js +7 -12
- package/src/direct/page.d.ts +34 -0
- package/src/direct/page.js +145 -0
- package/src/direct.d.ts +63 -0
- package/src/direct.js +411 -0
- package/src/espace/choses.d.ts +9 -0
- package/src/espace/choses.js +5 -0
- package/src/espace/coquille.js +4 -1
- package/src/espace/direct.d.ts +5 -0
- package/src/espace/direct.js +37 -0
- package/src/espace/ecran-d-une-chose.d.ts +4 -1
- package/src/espace/ecran-d-une-chose.js +20 -10
- package/src/espace/essai.d.ts +37 -0
- package/src/espace/essai.js +117 -0
- package/src/espace/index.d.ts +5 -2
- package/src/espace/index.js +5 -2
- package/src/espace/menu-d-une-chose.js +4 -4
- package/src/espace/navigation.d.ts +1 -0
- package/src/espace/navigation.js +4 -0
- package/src/espace/panneau-du-partage.js +3 -3
- package/src/faux-core.d.ts +23 -0
- package/src/faux-core.js +81 -0
- package/src/fichiers-d-une-chose.d.ts +37 -0
- package/src/fichiers-d-une-chose.js +136 -0
- package/src/forme-du-direct.d.ts +28 -0
- package/src/forme-du-direct.js +70 -0
- package/src/partage.js +1 -1
- package/src/presence.d.ts +8 -0
- package/src/presence.js +31 -0
- package/src/remplacements.d.ts +26 -0
- package/src/remplacements.js +41 -0
- package/src/sans-le-chemin.d.ts +1 -0
- package/src/sans-le-chemin.js +9 -0
- package/src/signaux.d.ts +5 -0
- package/src/signaux.js +20 -0
- package/src/ui/direct.d.ts +25 -0
- package/src/ui/direct.js +91 -0
- package/src/ui/etats.d.ts +1 -0
- package/src/ui/etats.js +3 -0
- package/src/ui/index.d.ts +2 -1
- package/src/ui/index.js +2 -1
- package/src/vite.js +4 -2
|
@@ -0,0 +1,117 @@
|
|
|
1
|
+
// @indos/bibliotheque/espace-d-essai : de quoi essayer la page de l'espace d'une pièce dans jsdom,
|
|
2
|
+
// par Vitest (bibliotheque/CLAUDE.md, « Les aides des tests ») : la session d'une personne, le
|
|
3
|
+
// serveur d'essai à la place de `fetch`, la page ouverte à une adresse, et le test commun des
|
|
4
|
+
// réglages d'une app à comptes branchés. Jamais chargé par une page servie.
|
|
5
|
+
import { createElement } from 'react';
|
|
6
|
+
import { render, screen, within } from '@testing-library/react';
|
|
7
|
+
import { createBrowserHistory, createRoute } from '@tanstack/react-router';
|
|
8
|
+
import { expect, test, vi } from 'vitest';
|
|
9
|
+
import { EcranDesComptes } from './comptes.js';
|
|
10
|
+
import { coquilleDeLEspace, creerLaPage } from './page.js';
|
|
11
|
+
// Une app ouverte dans la session, comme le core la rend : ses écrans sous son chemin, `/<nom>/…`,
|
|
12
|
+
// et son lien, à `http://localhost:3000`, vers son premier écran, sinon ses réglages.
|
|
13
|
+
export function appDEssai(nom, titre, { ecrans = [], reglages = false } = {}) {
|
|
14
|
+
const [premier] = ecrans;
|
|
15
|
+
const fin = premier ? `/${premier.nom}` : reglages ? '/reglages' : '';
|
|
16
|
+
return { nom, titre, lien: `http://localhost:3000/${nom}${fin}`, reglages, ecrans: ecrans.map((ecran) => ({ nom: ecran.nom, titre: ecran.titre, chemin: `/${nom}/${ecran.nom}` })) };
|
|
17
|
+
}
|
|
18
|
+
// La session d'une personne, dans la forme de `/espace/session` : Ada, propriétaire, sans groupe,
|
|
19
|
+
// les apps données ouvertes, la barre de leur premier écran, au titre de l'app, et le thème
|
|
20
|
+
// « Atelier », sans logo. `autres` remplace ce qui change.
|
|
21
|
+
export function sessionDEssai(apps = [], autres = {}) {
|
|
22
|
+
return {
|
|
23
|
+
id: 'ada',
|
|
24
|
+
email: 'ada@exemple.ch',
|
|
25
|
+
nom: 'Ada',
|
|
26
|
+
proprietaire: true,
|
|
27
|
+
groupes: [],
|
|
28
|
+
apps,
|
|
29
|
+
barre: apps.flatMap((app) => (app.ecrans[0] ? [{ titre: app.titre, chemin: app.ecrans[0].chemin, app: app.titre }] : [])),
|
|
30
|
+
theme: { nom: 'Atelier', logo: false },
|
|
31
|
+
...autres,
|
|
32
|
+
};
|
|
33
|
+
}
|
|
34
|
+
// Le résultat MCP d'un outil, tel que l'app le rend à son écran : un texte tel quel, toute autre
|
|
35
|
+
// valeur en JSON ; `enErreur`, un résultat qui n'a pas abouti.
|
|
36
|
+
export function resultat(valeur, enErreur = false) {
|
|
37
|
+
return { content: [{ type: 'text', text: typeof valeur === 'string' ? valeur : JSON.stringify(valeur) }], ...(enErreur ? { isError: true } : {}) };
|
|
38
|
+
}
|
|
39
|
+
// Le serveur d'essai, à la place de `fetch` : chaque chemin, sans l'origine (sa recherche gardée, ou
|
|
40
|
+
// sans elle s'il n'a pas de route avec), répond par sa fonction, qui reçoit le corps envoyé, lu en
|
|
41
|
+
// JSON ; un chemin sans route répond 404. Les appels sont gardés dans l'ordre. Le test retire le
|
|
42
|
+
// double par `vi.unstubAllGlobals()`.
|
|
43
|
+
export function servir(routes) {
|
|
44
|
+
const appels = [];
|
|
45
|
+
vi.stubGlobal('fetch', vi.fn(async (adresse, options = {}) => {
|
|
46
|
+
const url = new URL(String(adresse), 'http://localhost:3000');
|
|
47
|
+
const chemin = String(adresse).startsWith('/') ? String(adresse) : `${url.pathname}${url.search}`;
|
|
48
|
+
const corps = typeof options.body === 'string' ? JSON.parse(options.body) : options.body ?? undefined;
|
|
49
|
+
appels.push({ chemin, methode: options.method ?? 'GET', corps });
|
|
50
|
+
const route = routes[chemin] ?? routes[url.pathname];
|
|
51
|
+
const [statut, rendu] = route ? await route(corps) : [404, { erreur: 'Introuvable.' }];
|
|
52
|
+
return new Response(JSON.stringify(rendu), { status: statut, headers: { 'content-type': 'application/json' } });
|
|
53
|
+
}));
|
|
54
|
+
return appels;
|
|
55
|
+
}
|
|
56
|
+
// La page aux écrans donnés, ouverte à `adresse` dans l'historique du navigateur de jsdom, avec
|
|
57
|
+
// l'état `etat` de son entrée, comme une page rechargée. La pièce est `nom`, par défaut le premier
|
|
58
|
+
// segment de l'adresse ; sa base, `/<nom>/`, ou `/` pour le core. Rend son routeur, son client de
|
|
59
|
+
// requêtes et de quoi la démonter.
|
|
60
|
+
export function ouvrirLaPage(adresse, ecrans, options = {}) {
|
|
61
|
+
const nom = options.nom ?? adresse.split(/[/?#]/)[1] ?? '';
|
|
62
|
+
window.history.replaceState(options.etat ?? null, '', adresse);
|
|
63
|
+
const { Page, router, client } = creerLaPage({
|
|
64
|
+
piece: { nom, version: options.version ?? '0.1.0' },
|
|
65
|
+
base: nom === 'core' ? '/' : `/${nom}/`,
|
|
66
|
+
ecrans,
|
|
67
|
+
historique: createBrowserHistory(),
|
|
68
|
+
});
|
|
69
|
+
const rendu = render(createElement(Page));
|
|
70
|
+
return { router, client, demonter: rendu.unmount };
|
|
71
|
+
}
|
|
72
|
+
// Une description des comptes, pour le test commun : celle que les gestes de l'app rendraient.
|
|
73
|
+
const descriptionDEssai = {
|
|
74
|
+
titre: 'Les comptes',
|
|
75
|
+
presentation: 'Les comptes de Ada.',
|
|
76
|
+
aucun: 'Aucun compte branché.',
|
|
77
|
+
brancher: 'Brancher un compte',
|
|
78
|
+
retirer: 'Retirer ce compte',
|
|
79
|
+
etapes: [],
|
|
80
|
+
suites: ['Son accès est effacé de l\'OS.'],
|
|
81
|
+
faits: { branche: { titre: 'Compte branché' }, modifie: { titre: 'Modifications enregistrées' }, retire: { titre: 'Compte retiré' } },
|
|
82
|
+
champs: [
|
|
83
|
+
{ nom: 'serveur', libelle: 'Serveur', genre: 'texte', requis: true, avecLeSuivant: false, fixe: true },
|
|
84
|
+
{ nom: 'mot_de_passe', libelle: 'Mot de passe', genre: 'secret', requis: false, avecLeSuivant: false, fixe: false },
|
|
85
|
+
],
|
|
86
|
+
};
|
|
87
|
+
// Le test commun des réglages d'une app à comptes branchés (bibliotheque/CLAUDE.md, « L'écran des
|
|
88
|
+
// comptes ») : à `/<nom>/reglages`, l'écran commun des comptes s'ouvre dans le cadre de l'app,
|
|
89
|
+
// l'onglet « Réglages » actif, et lit la description et la liste des comptes par les gestes d'écran
|
|
90
|
+
// de l'app. `ecrans` sont ceux de la page de l'app ; par défaut, la route que sa page déclare,
|
|
91
|
+
// `EcranDesComptes` sous la coquille.
|
|
92
|
+
export function testerLEcranDesComptes(app, ecrans) {
|
|
93
|
+
test(`les réglages de ${app.titre} sont l'écran commun des comptes, dans le cadre de l'app, l'onglet « Réglages » actif`, async () => {
|
|
94
|
+
const session = sessionDEssai([appDEssai(app.nom, app.titre, { reglages: true })], { barre: [] });
|
|
95
|
+
const appels = servir({
|
|
96
|
+
'/espace/session': () => [200, session],
|
|
97
|
+
[`/${app.nom}/espace/comptes/decrire`]: () => [200, descriptionDEssai],
|
|
98
|
+
[`/${app.nom}/espace/comptes/lister`]: () => [200, { comptes: [] }],
|
|
99
|
+
});
|
|
100
|
+
try {
|
|
101
|
+
const reglages = createRoute({ getParentRoute: () => coquilleDeLEspace, path: `/${app.nom}/reglages`, component: EcranDesComptes });
|
|
102
|
+
ouvrirLaPage(`/${app.nom}/reglages`, ecrans ?? [reglages]);
|
|
103
|
+
expect((await screen.findByRole('heading', { level: 1 })).textContent).toBe('Réglages');
|
|
104
|
+
await screen.findByText('Aucun compte branché.');
|
|
105
|
+
const onglets = screen.getByRole('navigation', { name: 'Onglets' });
|
|
106
|
+
expect(within(onglets).getAllByRole('link').map((lien) => [lien.textContent, lien.getAttribute('href')])).toEqual([
|
|
107
|
+
['Réglages', `/${app.nom}/reglages`],
|
|
108
|
+
['Documentation', `/documentation/${app.nom}`],
|
|
109
|
+
]);
|
|
110
|
+
expect(within(onglets).getByRole('link', { name: 'Réglages' }).getAttribute('aria-current')).toBe('page');
|
|
111
|
+
expect(appels.map((appel) => appel.chemin)).toEqual(expect.arrayContaining([`/${app.nom}/espace/comptes/decrire`, `/${app.nom}/espace/comptes/lister`]));
|
|
112
|
+
}
|
|
113
|
+
finally {
|
|
114
|
+
vi.unstubAllGlobals();
|
|
115
|
+
}
|
|
116
|
+
});
|
|
117
|
+
}
|
package/src/espace/index.d.ts
CHANGED
|
@@ -13,9 +13,12 @@ export { EcranDesComptes } from './comptes.tsx';
|
|
|
13
13
|
export type { ChampDecrit, CompteListe, DescriptionDesComptes, ListeDesComptes } from '../description-des-comptes.ts';
|
|
14
14
|
export { desepingler, epingler, lireLAnnuaire, useEpingle, type AnnuaireDeLEcran, type Epingle } from './barre.ts';
|
|
15
15
|
export { useAnnoncer } from './ouvrir.ts';
|
|
16
|
-
export {
|
|
16
|
+
export { useAnnoncerLeDroitQuiBaisse, useMontrerLaChoseIntrouvable } from './direct.ts';
|
|
17
|
+
export { rechargerLaPage } from './navigation.ts';
|
|
18
|
+
export { chercherParLOutil, cleDesChoses, cleDUneChose, motsDeLaPublication, rechercheDeLaListe, useRelireLesChoses, vuesDuPartage, type AncetreDUneChose, type ChoseTrouvee, type ChosesTrouvees, type CiblesDuPartage, type ColonneDUneChose, type CritereDeRecherche, type DeclarationDesChoses, type DroitSurUneChose, type FenetreDuMenu, type FormulaireDUneFicheDeclare, type GesteDuMenu, type MotsDeLaPublication, type MotsDUnGeste, type OuvertureDUneChose, type RechercheDeLaListe, type VueDeLaListe, } from './choses.ts';
|
|
17
19
|
export { ListeDesChoses } from './liste-des-choses.tsx';
|
|
18
|
-
export {
|
|
20
|
+
export { DansLEtatDuDirect, EcranDUneChose } from './ecran-d-une-chose.tsx';
|
|
21
|
+
export { texteDUneChoseAbsente } from '../ui/etats.tsx';
|
|
19
22
|
export { MenuDUneChose, type ProprietesDuMenuDUneChose } from './menu-d-une-chose.tsx';
|
|
20
23
|
export { FormulaireDUneFiche, ModifierLaFiche, peutModifierLaFiche, type ProprietesDuFormulaireDUneFiche } from './formulaire-d-une-fiche.tsx';
|
|
21
24
|
export { ConfirmationDUnGeste, demandeLAccord, type AppelAConfirmer, type ProprietesDeLaConfirmationDUnGeste, type QuestionDUnGeste, } from './confirmation-d-un-geste.tsx';
|
package/src/espace/index.js
CHANGED
|
@@ -15,9 +15,12 @@ export { heureDeSuisse } from './heure.js';
|
|
|
15
15
|
export { EcranDesComptes } from './comptes.js';
|
|
16
16
|
export { desepingler, epingler, lireLAnnuaire, useEpingle } from './barre.js';
|
|
17
17
|
export { useAnnoncer } from './ouvrir.js';
|
|
18
|
-
export {
|
|
18
|
+
export { useAnnoncerLeDroitQuiBaisse, useMontrerLaChoseIntrouvable } from './direct.js';
|
|
19
|
+
export { rechargerLaPage } from './navigation.js';
|
|
20
|
+
export { chercherParLOutil, cleDesChoses, cleDUneChose, motsDeLaPublication, rechercheDeLaListe, useRelireLesChoses, vuesDuPartage, } from './choses.js';
|
|
19
21
|
export { ListeDesChoses } from './liste-des-choses.js';
|
|
20
|
-
export {
|
|
22
|
+
export { DansLEtatDuDirect, EcranDUneChose } from './ecran-d-une-chose.js';
|
|
23
|
+
export { texteDUneChoseAbsente } from '../ui/etats.js';
|
|
21
24
|
export { MenuDUneChose } from './menu-d-une-chose.js';
|
|
22
25
|
export { FormulaireDUneFiche, ModifierLaFiche, peutModifierLaFiche } from './formulaire-d-une-fiche.js';
|
|
23
26
|
export { ConfirmationDUnGeste, demandeLAccord, } from './confirmation-d-un-geste.js';
|
|
@@ -6,7 +6,7 @@ import { Confirmation } from '../ui/confirmation.js';
|
|
|
6
6
|
import { Fenetre } from '../ui/fenetre.js';
|
|
7
7
|
import { MenuDUneLigne } from '../ui/menu-d-une-ligne.js';
|
|
8
8
|
import { lireLAnnuaire, useEpingle } from './barre.js';
|
|
9
|
-
import { cleDesChoses, estRangee, motsDe } from './choses.js';
|
|
9
|
+
import { cleDesChoses, cleDUneChose, estRangee, motsDe } from './choses.js';
|
|
10
10
|
import { depuisLaListe, useAnnoncer, useOuvrir } from './ouvrir.js';
|
|
11
11
|
import { PanneauDuPartage } from './panneau-du-partage.js';
|
|
12
12
|
import { useSession } from './session.js';
|
|
@@ -31,8 +31,8 @@ export function MenuDUneChose({ choses, chose, surLEcran = false, surSupprimee }
|
|
|
31
31
|
const suppression = useMutation({
|
|
32
32
|
mutationFn: () => choses.supprimer(chose),
|
|
33
33
|
onSuccess: () => {
|
|
34
|
-
annoncer(motsDeLaSuppression.fait ?? `${LaChose} est supprimé${mots.e}.`);
|
|
35
|
-
client.removeQueries({ queryKey:
|
|
34
|
+
annoncer(motsDeLaSuppression.fait ?? `${LaChose} « ${chose.nom} » est supprimé${mots.e}.`);
|
|
35
|
+
client.removeQueries({ queryKey: cleDUneChose(choses, 'chose', chose.id) });
|
|
36
36
|
surSupprimee?.();
|
|
37
37
|
void relire();
|
|
38
38
|
},
|
|
@@ -103,7 +103,7 @@ function FenetreDuDon({ choses, chose, ouverte, onOuverteChange, retour, surFerm
|
|
|
103
103
|
annoncer(`« ${chose.nom} » est à ${options.find((option) => option.valeur === a)?.libelle ?? a}.`);
|
|
104
104
|
const encore = await choses.lire(chose.id).catch(() => undefined);
|
|
105
105
|
if (!encore) {
|
|
106
|
-
client.removeQueries({ queryKey:
|
|
106
|
+
client.removeQueries({ queryKey: cleDUneChose(choses, 'chose', chose.id) });
|
|
107
107
|
surFermee?.();
|
|
108
108
|
}
|
|
109
109
|
await client.invalidateQueries({ queryKey: cleDesChoses(choses.app) });
|
package/src/espace/navigation.js
CHANGED
|
@@ -7,7 +7,7 @@ import { Choix } from '../ui/choix.js';
|
|
|
7
7
|
import { cn } from '../ui/classes.js';
|
|
8
8
|
import { Panneau } from '../ui/panneau.js';
|
|
9
9
|
import { lireLAnnuaire } from './barre.js';
|
|
10
|
-
import { cleDesChoses, estRangee, motsDe, motsDeLaPublication, texteDuNoeud } from './choses.js';
|
|
10
|
+
import { cleDesChoses, cleDUneChose, estRangee, motsDe, motsDeLaPublication, texteDuNoeud } from './choses.js';
|
|
11
11
|
import { demandeLAccord } from './confirmation-d-un-geste.js';
|
|
12
12
|
import { useAnnoncer } from './ouvrir.js';
|
|
13
13
|
import { useSession } from './session.js';
|
|
@@ -59,7 +59,7 @@ function ContenuDuPartage({ choses, chose, mots }) {
|
|
|
59
59
|
// La liste des ouvertures, où va le focus quand « Retirer » fait partir sa ligne.
|
|
60
60
|
const ouverturesDeLaChose = useRef(null);
|
|
61
61
|
const partage = useQuery({
|
|
62
|
-
queryKey:
|
|
62
|
+
queryKey: cleDUneChose(choses, 'partage', chose.id),
|
|
63
63
|
queryFn: () => choses.lirePartage(chose),
|
|
64
64
|
staleTime: dureeDuPartageLu,
|
|
65
65
|
});
|
|
@@ -182,7 +182,7 @@ export function accesDe(choses, chose, ouvertures) {
|
|
|
182
182
|
export function PastilleDeLAcces({ choses, chose }) {
|
|
183
183
|
const client = useQueryClient();
|
|
184
184
|
const [ouvert, setOuvert] = useState(false);
|
|
185
|
-
const cle =
|
|
185
|
+
const cle = cleDUneChose(choses, 'partage', chose.id);
|
|
186
186
|
const partage = useQuery({ queryKey: cle, queryFn: () => choses.lirePartage(chose), enabled: Boolean(choses.lirePartage), staleTime: dureeDuPartageLu });
|
|
187
187
|
const acces = accesDe(choses, chose, partage.data);
|
|
188
188
|
const proprietaire = (chose.droit ?? 'proprietaire') === 'proprietaire';
|
package/src/faux-core.d.ts
CHANGED
|
@@ -1,5 +1,8 @@
|
|
|
1
1
|
import { type KeyObject } from 'node:crypto';
|
|
2
|
+
import { type IncomingMessage, type Server } from 'node:http';
|
|
2
3
|
import type { TestContext } from 'node:test';
|
|
4
|
+
import { Client } from '@modelcontextprotocol/client';
|
|
5
|
+
import { type TraitementDeLApp } from './app.ts';
|
|
3
6
|
import type { AppDeLaConsole, EntreeDeLaBarre } from './ecran.ts';
|
|
4
7
|
import type { Personne } from './jeton.ts';
|
|
5
8
|
import type { Annuaire } from './partage.ts';
|
|
@@ -29,3 +32,23 @@ export declare function lancerLeFauxCore(t: TestContext, sessions?: Record<strin
|
|
|
29
32
|
logo?: string;
|
|
30
33
|
nom?: string;
|
|
31
34
|
}, apps?: AppDeclaree[], annuaire?: Annuaire): Promise<string>;
|
|
35
|
+
export declare function servirLApp(t: TestContext, nom: string, options?: {
|
|
36
|
+
chemin?: (requete: IncomingMessage) => boolean;
|
|
37
|
+
hotePublic?: boolean;
|
|
38
|
+
}): Promise<{
|
|
39
|
+
serveur: Server<typeof IncomingMessage, typeof import("http").ServerResponse>;
|
|
40
|
+
port: number;
|
|
41
|
+
origine: string;
|
|
42
|
+
adresse: string;
|
|
43
|
+
adressePublique: string | undefined;
|
|
44
|
+
brancher(traiter: TraitementDeLApp): void;
|
|
45
|
+
}>;
|
|
46
|
+
export type ClientDEssai = Client;
|
|
47
|
+
export declare function connecter(t: TestContext, adresse: string, personne: Personne | string, app?: string): Promise<ClientDEssai>;
|
|
48
|
+
export type ResultatLu = {
|
|
49
|
+
erreur: boolean;
|
|
50
|
+
refus: boolean;
|
|
51
|
+
texte: string;
|
|
52
|
+
json: any;
|
|
53
|
+
};
|
|
54
|
+
export declare function appeler(client: ClientDEssai, outil: string, arguments_?: Record<string, unknown>, options?: Parameters<Client['callTool']>[1]): Promise<ResultatLu>;
|
package/src/faux-core.js
CHANGED
|
@@ -1,6 +1,9 @@
|
|
|
1
1
|
import { generateKeyPairSync, sign } from 'node:crypto';
|
|
2
2
|
import { once } from 'node:events';
|
|
3
3
|
import { createServer } from 'node:http';
|
|
4
|
+
import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
|
|
5
|
+
import { creerLeServeur } from './app.js';
|
|
6
|
+
import { sansLeChemin } from './sans-le-chemin.js';
|
|
4
7
|
// Un faux core pour les tests des apps : il sert sa clé publique et signe des jetons, fabriqués
|
|
5
8
|
// ici à la main, sans le code du core.
|
|
6
9
|
export const { privateKey: cleDuFauxCore, publicKey: clePubliqueDuFauxCore } = generateKeyPairSync('ed25519');
|
|
@@ -112,3 +115,81 @@ export async function lancerLeFauxCore(t, sessions = {}, theme = {}, apps = [],
|
|
|
112
115
|
await once(serveur, 'listening');
|
|
113
116
|
return `http://127.0.0.1:${serveur.address().port}`;
|
|
114
117
|
}
|
|
118
|
+
// Une app à l'essai, servie comme `demarrerLApp` la sert derrière le proxy : sur un port libre de
|
|
119
|
+
// 127.0.0.1, son chemin (`/<nom>`) retiré de chaque requête qui le porte, sauf là où `chemin` le
|
|
120
|
+
// garde, comme l'option du même nom de `demarrerLApp`. Avec `hotePublic`, elle écoute sur toutes les
|
|
121
|
+
// interfaces et se joint aussi par `localhost`, son hôte public (`adressePublique`), où elle garde son
|
|
122
|
+
// chemin, sauf si `chemin` en dit autrement. L'erreur d'un traitement coupe la connexion. Elle rend son
|
|
123
|
+
// `adresse`, avec son chemin, son `origine`, son `port`, son `serveur` (pour un WebSocket), et
|
|
124
|
+
// `brancher(traitement)`, qui lui donne son traitement une fois créé : jusque-là, elle répond vide.
|
|
125
|
+
// Elle s'arrête à la fin du test.
|
|
126
|
+
export async function servirLApp(t, nom, options = {}) {
|
|
127
|
+
let traitement;
|
|
128
|
+
let hotePublic;
|
|
129
|
+
const retirer = options.chemin ?? ((requete) => requete.headers.host !== hotePublic);
|
|
130
|
+
const serveur = creerLeServeur((requete, reponse) => {
|
|
131
|
+
if (retirer(requete)) {
|
|
132
|
+
requete.url = sansLeChemin(requete.url ?? '/', `/${nom}`);
|
|
133
|
+
}
|
|
134
|
+
if (!traitement) {
|
|
135
|
+
reponse.end();
|
|
136
|
+
return;
|
|
137
|
+
}
|
|
138
|
+
try {
|
|
139
|
+
Promise.resolve(traitement(requete, reponse)).catch((erreur) => reponse.destroy(erreur));
|
|
140
|
+
}
|
|
141
|
+
catch (erreur) {
|
|
142
|
+
reponse.destroy(erreur);
|
|
143
|
+
}
|
|
144
|
+
});
|
|
145
|
+
serveur.listen(0, options.hotePublic ? undefined : '127.0.0.1');
|
|
146
|
+
await once(serveur, 'listening');
|
|
147
|
+
t.after(() => {
|
|
148
|
+
serveur.closeAllConnections();
|
|
149
|
+
serveur.close();
|
|
150
|
+
});
|
|
151
|
+
const port = serveur.address().port;
|
|
152
|
+
const origine = `http://127.0.0.1:${port}`;
|
|
153
|
+
const adressePublique = options.hotePublic ? `http://localhost:${port}` : undefined;
|
|
154
|
+
hotePublic = adressePublique && new URL(adressePublique).host;
|
|
155
|
+
return {
|
|
156
|
+
serveur,
|
|
157
|
+
port,
|
|
158
|
+
origine,
|
|
159
|
+
adresse: `${origine}/${nom}`,
|
|
160
|
+
adressePublique,
|
|
161
|
+
brancher(traiter) {
|
|
162
|
+
traitement = traiter;
|
|
163
|
+
},
|
|
164
|
+
};
|
|
165
|
+
}
|
|
166
|
+
// Un client MCP pour la personne, comme le core qui relaie Claude, sur `<adresse>/mcp` : il présente
|
|
167
|
+
// le jeton du faux core pour l'app, `app`, par défaut le dernier segment du chemin d'`adresse`, comme
|
|
168
|
+
// le nom d'une app dans son `ADRESSE`. Une chaîne à la place de la personne est un jeton présenté tel
|
|
169
|
+
// quel. Le client se ferme à la fin du test.
|
|
170
|
+
export async function connecter(t, adresse, personne, app) {
|
|
171
|
+
let jeton = personne;
|
|
172
|
+
if (typeof jeton !== 'string') {
|
|
173
|
+
const nom = app ?? new URL(adresse).pathname.split('/').filter(Boolean).at(-1);
|
|
174
|
+
if (!nom) {
|
|
175
|
+
throw new Error(`L'adresse ${adresse} n'a pas de chemin : donnez le nom de l'app à connecter.`);
|
|
176
|
+
}
|
|
177
|
+
jeton = fabriquerUnJeton(jeton, nom);
|
|
178
|
+
}
|
|
179
|
+
const client = new Client({ name: 'essai', version: '1.0.0' });
|
|
180
|
+
await client.connect(new StreamableHTTPClientTransport(new URL(`${adresse}/mcp`), { requestInit: { headers: { authorization: `Bearer ${jeton}` } } }));
|
|
181
|
+
t.after(() => client.close());
|
|
182
|
+
return client;
|
|
183
|
+
}
|
|
184
|
+
// Appelle l'outil par le client de `connecter`, et rend son résultat lu. `options` sont celles du
|
|
185
|
+
// client MCP pour cet appel, comme un `timeout` plus long que la minute par défaut.
|
|
186
|
+
export async function appeler(client, outil, arguments_ = {}, options) {
|
|
187
|
+
const resultat = await client.callTool({ name: outil, arguments: arguments_ }, options);
|
|
188
|
+
const texte = resultat.content.find((partie) => partie.type === 'text')?.text ?? '';
|
|
189
|
+
return {
|
|
190
|
+
erreur: resultat.isError === true,
|
|
191
|
+
refus: resultat._meta?.['indos/refus'] === true,
|
|
192
|
+
texte,
|
|
193
|
+
json: /^[[{]/.test(texte) ? JSON.parse(texte) : undefined,
|
|
194
|
+
};
|
|
195
|
+
}
|
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
import type pg from 'pg';
|
|
2
|
+
export type FichierDUneChose = {
|
|
3
|
+
chemin: string;
|
|
4
|
+
type: string;
|
|
5
|
+
taille: number;
|
|
6
|
+
};
|
|
7
|
+
export type FichierLu = FichierDUneChose & {
|
|
8
|
+
contenu: Buffer;
|
|
9
|
+
};
|
|
10
|
+
export type TexteLu = FichierDUneChose & {
|
|
11
|
+
texte: string;
|
|
12
|
+
};
|
|
13
|
+
export declare const deuxMo: number;
|
|
14
|
+
export declare function estUnChemin(chemin: string): boolean;
|
|
15
|
+
export declare function estUnDossier(chemin: string): boolean;
|
|
16
|
+
export declare const formeDUnChemin = "Un chemin de fichier : des segments de lettres, chiffres, `.`, `_` et `-`, s\u00E9par\u00E9s par `/`, dont aucun ne commence par un point ou un tiret, 300 caract\u00E8res au plus ; un dossier finit par `/`.";
|
|
17
|
+
export declare function typeDuChemin(chemin: string): string | undefined;
|
|
18
|
+
export declare function typeSain(type: string): string | undefined;
|
|
19
|
+
export declare function estUnTexte(type: string): boolean;
|
|
20
|
+
export declare function texteDe(octets: Buffer): string | undefined;
|
|
21
|
+
export type OptionsDesFichiers = {
|
|
22
|
+
chose: string;
|
|
23
|
+
laChose: string;
|
|
24
|
+
};
|
|
25
|
+
export declare function creerLesFichiersDUneChose({ chose: nomDeLaChose, laChose }: OptionsDesFichiers): {
|
|
26
|
+
lesFichiers(base: pg.Pool | pg.PoolClient, id: string): Promise<FichierDUneChose[]>;
|
|
27
|
+
lireLesFichiers: (base: pg.Pool | pg.PoolClient, id: string, chemins: string[]) => Promise<Map<string, FichierLu>>;
|
|
28
|
+
lireUnTexte(base: pg.Pool | pg.PoolClient, id: string, chemin: string): Promise<TexteLu>;
|
|
29
|
+
lireDesTextes(base: pg.Pool | pg.PoolClient, id: string, chemins: string[]): Promise<(TexteLu | {
|
|
30
|
+
chemin: string;
|
|
31
|
+
erreur: string;
|
|
32
|
+
})[]>;
|
|
33
|
+
poser(client: pg.PoolClient, id: string, chemin: string, type: string, contenu: Buffer): Promise<FichierDUneChose>;
|
|
34
|
+
copier(client: pg.PoolClient, source: string, depuis: string, cible: string, vers: string): Promise<FichierDUneChose[]>;
|
|
35
|
+
retirer(client: pg.PoolClient, id: string, chemin: string): Promise<string[]>;
|
|
36
|
+
};
|
|
37
|
+
export type FichiersDUneChose = ReturnType<typeof creerLesFichiersDUneChose>;
|
|
@@ -0,0 +1,136 @@
|
|
|
1
|
+
export const deuxMo = 2 * 1024 * 1024;
|
|
2
|
+
// Un chemin : des segments de lettres, chiffres, `.`, `_` et `-`, séparés par `/`, dont aucun ne
|
|
3
|
+
// commence par un point ou un tiret ; un dossier : un chemin suivi de `/`.
|
|
4
|
+
const segments = '[A-Za-z0-9_][A-Za-z0-9._-]*(/[A-Za-z0-9_][A-Za-z0-9._-]*)*';
|
|
5
|
+
const unChemin = new RegExp(`^${segments}$`);
|
|
6
|
+
const unDossier = new RegExp(`^${segments}/$`);
|
|
7
|
+
export function estUnChemin(chemin) {
|
|
8
|
+
return chemin.length <= 300 && unChemin.test(chemin);
|
|
9
|
+
}
|
|
10
|
+
export function estUnDossier(chemin) {
|
|
11
|
+
return chemin.length <= 300 && unDossier.test(chemin);
|
|
12
|
+
}
|
|
13
|
+
export const formeDUnChemin = 'Un chemin de fichier : des segments de lettres, chiffres, `.`, `_` et `-`, séparés par `/`, dont aucun ne commence par un point ou un tiret, 300 caractères au plus ; un dossier finit par `/`.';
|
|
14
|
+
// Le type d'un fichier d'après l'extension de son chemin : celui que le navigateur attend.
|
|
15
|
+
const types = {
|
|
16
|
+
html: 'text/html', css: 'text/css', js: 'text/javascript', mjs: 'text/javascript', json: 'application/json',
|
|
17
|
+
md: 'text/markdown', txt: 'text/plain', csv: 'text/csv', xml: 'application/xml', svg: 'image/svg+xml',
|
|
18
|
+
png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp', avif: 'image/avif', ico: 'image/x-icon',
|
|
19
|
+
woff: 'font/woff', woff2: 'font/woff2', ttf: 'font/ttf', otf: 'font/otf',
|
|
20
|
+
pdf: 'application/pdf', mp3: 'audio/mpeg', mp4: 'video/mp4', webm: 'video/webm', wasm: 'application/wasm',
|
|
21
|
+
};
|
|
22
|
+
export function typeDuChemin(chemin) {
|
|
23
|
+
const point = chemin.lastIndexOf('.');
|
|
24
|
+
return point > chemin.lastIndexOf('/') ? types[chemin.slice(point + 1).toLowerCase()] : undefined;
|
|
25
|
+
}
|
|
26
|
+
// Un type MIME tel que la base l'accepte : en minuscules, sans paramètre.
|
|
27
|
+
const unType = /^[a-z]+\/[a-z0-9.+-]+$/;
|
|
28
|
+
export function typeSain(type) {
|
|
29
|
+
const nu = type.split(';')[0]?.trim().toLowerCase() ?? '';
|
|
30
|
+
return unType.test(nu) ? nu : undefined;
|
|
31
|
+
}
|
|
32
|
+
// Un fichier se lit en texte quand son type le dit et que ses octets sont de l'UTF-8.
|
|
33
|
+
export function estUnTexte(type) {
|
|
34
|
+
return /^text\/|^application\/(json|javascript|xml)$|\+(json|xml)$/.test(type);
|
|
35
|
+
}
|
|
36
|
+
export function texteDe(octets) {
|
|
37
|
+
try {
|
|
38
|
+
return new TextDecoder('utf-8', { fatal: true }).decode(octets);
|
|
39
|
+
}
|
|
40
|
+
catch {
|
|
41
|
+
return undefined;
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
// Les gestes sur les fichiers des choses de l'app. Une lecture prend la base ou la connexion d'une
|
|
45
|
+
// transaction ; une écriture, la connexion de la transaction de la chose (`enTransaction`), qui
|
|
46
|
+
// tient son verrou et sa date de modification.
|
|
47
|
+
export function creerLesFichiersDUneChose({ chose: nomDeLaChose, laChose }) {
|
|
48
|
+
if (!/^[a-z_][a-z0-9_]*$/.test(nomDeLaChose)) {
|
|
49
|
+
throw new Error(`« ${nomDeLaChose} » n'est pas un nom de colonne.`);
|
|
50
|
+
}
|
|
51
|
+
const chose = nomDeLaChose;
|
|
52
|
+
const LaChose = `${laChose.charAt(0).toUpperCase()}${laChose.slice(1)}`;
|
|
53
|
+
// Le texte d'un fichier lu, ou une erreur qui dit pourquoi il ne se lit pas.
|
|
54
|
+
function texteDuFichier(chemin, fichier) {
|
|
55
|
+
if (!fichier) {
|
|
56
|
+
throw new Error(`${LaChose} n'a pas de fichier « ${chemin} » : \`lire\` sans \`chemins\` donne ses fichiers.`);
|
|
57
|
+
}
|
|
58
|
+
if (!estUnTexte(fichier.type)) {
|
|
59
|
+
throw new Error(`« ${chemin} » n'est pas un fichier texte (${fichier.type}).`);
|
|
60
|
+
}
|
|
61
|
+
const texte = texteDe(fichier.contenu);
|
|
62
|
+
if (texte === undefined) {
|
|
63
|
+
throw new Error(`« ${chemin} » (${fichier.type}) n'est pas écrit en UTF-8 : il ne se lit pas en texte.`);
|
|
64
|
+
}
|
|
65
|
+
return { chemin, type: fichier.type, taille: fichier.taille, texte };
|
|
66
|
+
}
|
|
67
|
+
// Les fichiers de ces chemins, avec leurs octets.
|
|
68
|
+
async function lireLesFichiers(base, id, chemins) {
|
|
69
|
+
if (chemins.length === 0) {
|
|
70
|
+
return new Map();
|
|
71
|
+
}
|
|
72
|
+
const { rows } = await base.query(`select chemin, type, taille, contenu from fichier where ${chose} = $1 and chemin = any($2)`, [id, chemins]);
|
|
73
|
+
return new Map(rows.map((fichier) => [fichier.chemin, fichier]));
|
|
74
|
+
}
|
|
75
|
+
return {
|
|
76
|
+
// Les fichiers d'une chose, sans leur contenu, du premier au dernier chemin.
|
|
77
|
+
async lesFichiers(base, id) {
|
|
78
|
+
const { rows } = await base.query(`select chemin, type, taille from fichier where ${chose} = $1 order by chemin`, [id]);
|
|
79
|
+
return rows;
|
|
80
|
+
},
|
|
81
|
+
lireLesFichiers,
|
|
82
|
+
// Le fichier texte de ce chemin, avec son texte, ou une erreur qui dit pourquoi il ne se lit pas.
|
|
83
|
+
async lireUnTexte(base, id, chemin) {
|
|
84
|
+
return texteDuFichier(chemin, (await lireLesFichiers(base, id, [chemin])).get(chemin));
|
|
85
|
+
},
|
|
86
|
+
// Les fichiers texte de ces chemins, dans l'ordre demandé : chacun avec son texte, ou ce qui
|
|
87
|
+
// l'empêche de se lire.
|
|
88
|
+
async lireDesTextes(base, id, chemins) {
|
|
89
|
+
const uniques = [...new Set(chemins)];
|
|
90
|
+
const lus = await lireLesFichiers(base, id, uniques);
|
|
91
|
+
return uniques.map((chemin) => {
|
|
92
|
+
try {
|
|
93
|
+
return texteDuFichier(chemin, lus.get(chemin));
|
|
94
|
+
}
|
|
95
|
+
catch (erreur) {
|
|
96
|
+
return { chemin, erreur: erreur.message };
|
|
97
|
+
}
|
|
98
|
+
});
|
|
99
|
+
},
|
|
100
|
+
// Pose un fichier sous son chemin : le crée, ou remplace celui du même chemin.
|
|
101
|
+
async poser(client, id, chemin, type, contenu) {
|
|
102
|
+
if (contenu.length > deuxMo) {
|
|
103
|
+
throw new Error(`« ${chemin} » fait ${contenu.length} octets : un fichier en fait 2 Mo au plus.`);
|
|
104
|
+
}
|
|
105
|
+
const { rows } = await client.query(`insert into fichier (${chose}, chemin, type, contenu) values ($1, $2, $3, $4)
|
|
106
|
+
on conflict (${chose}, chemin) do update set type = excluded.type, contenu = excluded.contenu, modifie_le = now()
|
|
107
|
+
returning chemin, type, taille`, [id, chemin, type, contenu]);
|
|
108
|
+
return rows[0];
|
|
109
|
+
},
|
|
110
|
+
// Copie, en une requête, le fichier `depuis` de la chose source sous `vers` dans la chose cible,
|
|
111
|
+
// ou, quand les deux finissent par `/`, tous ses fichiers sous ce dossier dans le dossier cible.
|
|
112
|
+
// Un fichier du même chemin dans la cible est remplacé ; chaque fichier garde son type.
|
|
113
|
+
async copier(client, source, depuis, cible, vers) {
|
|
114
|
+
const dossier = depuis.endsWith('/');
|
|
115
|
+
const { rows } = await client.query(`insert into fichier (${chose}, chemin, type, contenu)
|
|
116
|
+
select $3, case when $5 then $4 || substr(chemin, length($2) + 1) else $4 end, type, contenu
|
|
117
|
+
from fichier
|
|
118
|
+
where ${chose} = $1 and case when $5 then starts_with(chemin, $2) else chemin = $2 end
|
|
119
|
+
order by chemin
|
|
120
|
+
on conflict (${chose}, chemin) do update set type = excluded.type, contenu = excluded.contenu, modifie_le = now()
|
|
121
|
+
returning chemin, type, taille`, [source, depuis, cible, vers, dossier]);
|
|
122
|
+
if (rows.length === 0) {
|
|
123
|
+
throw new Error(`${LaChose} source n'a aucun fichier « ${depuis} ».`);
|
|
124
|
+
}
|
|
125
|
+
return rows;
|
|
126
|
+
},
|
|
127
|
+
// Retire le fichier de ce chemin, ou tous ceux d'un dossier, et rend les chemins retirés.
|
|
128
|
+
async retirer(client, id, chemin) {
|
|
129
|
+
const { rows } = await client.query(`delete from fichier where ${chose} = $1 and case when $3 then starts_with(chemin, $2) else chemin = $2 end returning chemin`, [id, chemin, chemin.endsWith('/')]);
|
|
130
|
+
if (rows.length === 0) {
|
|
131
|
+
throw new Error(`${LaChose} n'a aucun fichier « ${chemin} ».`);
|
|
132
|
+
}
|
|
133
|
+
return rows.map((ligne) => ligne.chemin).sort();
|
|
134
|
+
},
|
|
135
|
+
};
|
|
136
|
+
}
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
import { type PersonnePresente } from './presence.ts';
|
|
2
|
+
export declare const cheminDuDirect = "direct";
|
|
3
|
+
export declare const raisons: {
|
|
4
|
+
readonly introuvable: 'introuvable';
|
|
5
|
+
readonly plusOuvert: 'plus ouvert par ce lien';
|
|
6
|
+
readonly connexion: 'connexion requise';
|
|
7
|
+
readonly reessayez: 'réessayez';
|
|
8
|
+
readonly origine: 'origine refusée';
|
|
9
|
+
};
|
|
10
|
+
export declare const codes: {
|
|
11
|
+
readonly droitChange: 4205;
|
|
12
|
+
readonly plusDeDroit: 4403;
|
|
13
|
+
readonly redemarrage: 1012;
|
|
14
|
+
};
|
|
15
|
+
export declare function estUneChoseAbsente(raison: string): boolean;
|
|
16
|
+
export type Invite = {
|
|
17
|
+
id: string;
|
|
18
|
+
prenom: string;
|
|
19
|
+
};
|
|
20
|
+
export declare function personneDeLInvite(donne: unknown, tirer: () => string): PersonnePresente;
|
|
21
|
+
export type OngletPresent = {
|
|
22
|
+
client: number;
|
|
23
|
+
personne: PersonnePresente;
|
|
24
|
+
etat: Record<string, unknown>;
|
|
25
|
+
};
|
|
26
|
+
export declare function personneDeLEtat(etat: unknown): PersonnePresente | undefined;
|
|
27
|
+
export declare function ongletsDesAutres(etats: Map<number, unknown>, client: number): OngletPresent[];
|
|
28
|
+
export declare function personnesDesAutres(etats: Map<number, unknown>, client: number): PersonnePresente[];
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
import { longueurDUnNom } from './presence.js';
|
|
2
|
+
// La forme commune du direct Yjs, la même au serveur (`@indos/bibliotheque/direct`) et à la page
|
|
3
|
+
// (`@indos/bibliotheque/direct/page`), sans rien de Node ni du navigateur (bibliotheque/CLAUDE.md,
|
|
4
|
+
// « Le direct Yjs ») : son chemin, les raisons de ses refus, ses codes de fermeture et la présence
|
|
5
|
+
// que le serveur écrit.
|
|
6
|
+
// Le chemin du direct d'une chose, sous l'app : `direct/<id>`.
|
|
7
|
+
export const cheminDuDirect = 'direct';
|
|
8
|
+
// Pourquoi le serveur refuse une connexion : la page reçoit la raison à l'ouverture
|
|
9
|
+
// (`onAuthenticationFailed`), ou avec la fermeture 4403. « réessayez » (le core ou la base ne
|
|
10
|
+
// répondent pas) se réessaie seul ; les autres ferment le direct.
|
|
11
|
+
export const raisons = {
|
|
12
|
+
introuvable: 'introuvable',
|
|
13
|
+
plusOuvert: 'plus ouvert par ce lien',
|
|
14
|
+
connexion: 'connexion requise',
|
|
15
|
+
reessayez: 'réessayez',
|
|
16
|
+
origine: 'origine refusée',
|
|
17
|
+
};
|
|
18
|
+
// Les codes de fermeture du serveur : le droit a changé, la page se rouvre au nouveau ; plus de
|
|
19
|
+
// droit, la page ferme le direct, avec la raison ; l'app redémarre, la page se rouvre.
|
|
20
|
+
export const codes = { droitChange: 4205, plusDeDroit: 4403, redemarrage: 1012 };
|
|
21
|
+
// La raison d'un refus qui dit une chose absente, ou qui n'est plus ouverte à la personne : l'écran
|
|
22
|
+
// commun d'une chose introuvable la remplace.
|
|
23
|
+
export function estUneChoseAbsente(raison) {
|
|
24
|
+
return raison === raisons.introuvable || raison === raisons.plusOuvert;
|
|
25
|
+
}
|
|
26
|
+
const formeDUnUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
|
27
|
+
// La présence d'un invité, tirée de ce que sa page envoie : son identifiant, un UUID, sinon un
|
|
28
|
+
// identifiant tiré par le serveur ; son prénom, sans les espaces autour, borné à 24 caractères,
|
|
29
|
+
// « Invité » quand il est vide.
|
|
30
|
+
export function personneDeLInvite(donne, tirer) {
|
|
31
|
+
const invite = donne && typeof donne === 'object' ? donne : {};
|
|
32
|
+
const id = typeof invite.id === 'string' && formeDUnUuid.test(invite.id) ? invite.id.toLowerCase() : tirer();
|
|
33
|
+
const prenom = typeof invite.prenom === 'string' ? Array.from(invite.prenom.trim()).slice(0, longueurDUnNom).join('').trim() : '';
|
|
34
|
+
return { id, nom: prenom || 'Invité', invite: true };
|
|
35
|
+
}
|
|
36
|
+
// La personne qu'un état de présence porte, écrite par le serveur, ou rien.
|
|
37
|
+
export function personneDeLEtat(etat) {
|
|
38
|
+
const personne = etat && typeof etat === 'object' ? etat.personne : undefined;
|
|
39
|
+
if (!personne || typeof personne !== 'object') {
|
|
40
|
+
return undefined;
|
|
41
|
+
}
|
|
42
|
+
const { id, nom, invite } = personne;
|
|
43
|
+
if (typeof id !== 'string' || typeof nom !== 'string') {
|
|
44
|
+
return undefined;
|
|
45
|
+
}
|
|
46
|
+
return { id, nom, ...(invite === true ? { invite: true } : {}) };
|
|
47
|
+
}
|
|
48
|
+
// Les onglets des autres, d'après les états de présence (`awareness.getStates()`), sans celui de la
|
|
49
|
+
// page (`client`, son `clientID`) : ceux qui portent une personne, dans l'ordre des états.
|
|
50
|
+
export function ongletsDesAutres(etats, client) {
|
|
51
|
+
const onglets = [];
|
|
52
|
+
for (const [autre, etat] of etats) {
|
|
53
|
+
const personne = autre === client ? undefined : personneDeLEtat(etat);
|
|
54
|
+
if (personne) {
|
|
55
|
+
onglets.push({ client: autre, personne, etat: etat });
|
|
56
|
+
}
|
|
57
|
+
}
|
|
58
|
+
return onglets;
|
|
59
|
+
}
|
|
60
|
+
// Les autres personnes présentes, une fois chacune quel que soit le nombre de ses onglets : les
|
|
61
|
+
// `autres` d'`EtatEtPresences`.
|
|
62
|
+
export function personnesDesAutres(etats, client) {
|
|
63
|
+
const personnes = new Map();
|
|
64
|
+
for (const { personne } of ongletsDesAutres(etats, client)) {
|
|
65
|
+
if (!personnes.has(personne.id)) {
|
|
66
|
+
personnes.set(personne.id, personne);
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
return [...personnes.values()];
|
|
70
|
+
}
|
package/src/partage.js
CHANGED
|
@@ -390,7 +390,7 @@ export function creerLePartage(options) {
|
|
|
390
390
|
const annuaire = await lireLAnnuaire({ sansCache: true });
|
|
391
391
|
const de = personneDuCourriel(annuaire, arguments_.de, 'Rien n\'est donné');
|
|
392
392
|
if (de.active) {
|
|
393
|
-
throw new Refus(`Rien n'est donné : ${de.nom} (${de.email}) est encore
|
|
393
|
+
throw new Refus(`Rien n'est donné : le compte de ${de.nom} (${de.email}) est encore actif. Ses choses ne se donnent ainsi qu'une fois la personne désactivée, dans « Équipe ».`);
|
|
394
394
|
}
|
|
395
395
|
const a = personneDuCourriel(annuaire, arguments_.a, 'Rien n\'est donné');
|
|
396
396
|
if (!a.active) {
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
export type PersonnePresente = {
|
|
2
|
+
id: string;
|
|
3
|
+
nom: string;
|
|
4
|
+
invite?: boolean;
|
|
5
|
+
};
|
|
6
|
+
export declare const longueurDUnNom = 24;
|
|
7
|
+
export declare const couleursDesPersonnes: readonly ['#2b6dc9', '#c6327c', '#1f7d4e', '#996216', '#9a49c2', '#177a83', '#4a7a29', '#6262cb'];
|
|
8
|
+
export declare function couleurDe(id: string): string;
|