@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.
Files changed (44) hide show
  1. package/CHANGELOG.md +36 -0
  2. package/package.json +37 -2
  3. package/src/app.js +7 -12
  4. package/src/direct/page.d.ts +34 -0
  5. package/src/direct/page.js +145 -0
  6. package/src/direct.d.ts +63 -0
  7. package/src/direct.js +411 -0
  8. package/src/espace/choses.d.ts +9 -0
  9. package/src/espace/choses.js +5 -0
  10. package/src/espace/coquille.js +4 -1
  11. package/src/espace/direct.d.ts +5 -0
  12. package/src/espace/direct.js +37 -0
  13. package/src/espace/ecran-d-une-chose.d.ts +4 -1
  14. package/src/espace/ecran-d-une-chose.js +20 -10
  15. package/src/espace/essai.d.ts +37 -0
  16. package/src/espace/essai.js +117 -0
  17. package/src/espace/index.d.ts +5 -2
  18. package/src/espace/index.js +5 -2
  19. package/src/espace/menu-d-une-chose.js +4 -4
  20. package/src/espace/navigation.d.ts +1 -0
  21. package/src/espace/navigation.js +4 -0
  22. package/src/espace/panneau-du-partage.js +3 -3
  23. package/src/faux-core.d.ts +23 -0
  24. package/src/faux-core.js +81 -0
  25. package/src/fichiers-d-une-chose.d.ts +37 -0
  26. package/src/fichiers-d-une-chose.js +136 -0
  27. package/src/forme-du-direct.d.ts +28 -0
  28. package/src/forme-du-direct.js +70 -0
  29. package/src/partage.js +1 -1
  30. package/src/presence.d.ts +8 -0
  31. package/src/presence.js +31 -0
  32. package/src/remplacements.d.ts +26 -0
  33. package/src/remplacements.js +41 -0
  34. package/src/sans-le-chemin.d.ts +1 -0
  35. package/src/sans-le-chemin.js +9 -0
  36. package/src/signaux.d.ts +5 -0
  37. package/src/signaux.js +20 -0
  38. package/src/ui/direct.d.ts +25 -0
  39. package/src/ui/direct.js +91 -0
  40. package/src/ui/etats.d.ts +1 -0
  41. package/src/ui/etats.js +3 -0
  42. package/src/ui/index.d.ts +2 -1
  43. package/src/ui/index.js +2 -1
  44. package/src/vite.js +4 -2
package/src/direct.js ADDED
@@ -0,0 +1,411 @@
1
+ import { randomUUID } from 'node:crypto';
2
+ import { Hocuspocus } from '@hocuspocus/server';
3
+ import { WebSocketServer } from 'ws';
4
+ import * as Y from 'yjs';
5
+ import { delaiDuBattement } from './flux.js';
6
+ import { cheminDuDirect, codes, personneDeLInvite, raisons } from './forme-du-direct.js';
7
+ import { Refus } from './mcp.js';
8
+ import { suffit } from './partage.js';
9
+ import { couleurDe, longueurDUnNom } from './presence.js';
10
+ // @indos/bibliotheque/direct : le direct Yjs d'une app, côté serveur (bibliotheque/CLAUDE.md, « Le
11
+ // direct Yjs »). Chaque chose ouverte est un document Yjs en mémoire de l'app, relayé par Hocuspocus
12
+ // à chaque page qui l'a ouverte, par un WebSocket, et écrit en base par l'app. Une seule instance par
13
+ // serveur : un redémarrage coupe les connexions, que les pages rouvrent seules, et l'app écrit ses
14
+ // choses ouvertes avant de quitter.
15
+ export { cheminDuDirect, codes, raisons } from './forme-du-direct.js';
16
+ // Un message de plus de 2 Mo ferme sa connexion (1009).
17
+ export const tailleMaximaleDUnMessage = 2 * 1024 * 1024;
18
+ // Le droit de chaque connexion se relit toutes les cinq minutes.
19
+ export const delaiDeRelecture = 5 * 60_000;
20
+ // Un refus du direct : Hocuspocus envoie sa raison à la page, sans rien écrire au journal.
21
+ const refuser = (raison) => ({ reason: raison });
22
+ // Le chemin d'un direct, sans celui de l'app : `/direct/<id>`, l'identifiant de la chose un UUID.
23
+ const cheminDUnDirect = new RegExp(`^/${cheminDuDirect}/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$`, 'i');
24
+ // Lit ce qu'un invité envoie à l'ouverture, en JSON ; rien sinon.
25
+ function lireLeJeton(jeton) {
26
+ try {
27
+ return JSON.parse(jeton);
28
+ }
29
+ catch {
30
+ return undefined;
31
+ }
32
+ }
33
+ export function creerLeDirectYjs(reglages) {
34
+ const { adresse, adressePublique, session, limite } = reglages;
35
+ if (adressePublique && !reglages.estPubliee) {
36
+ throw new Error('Le direct sur l\'hôte public demande estPubliee.');
37
+ }
38
+ const prefixe = new URL(adresse).pathname.replace(/\/$/, '');
39
+ const origineDuDomaine = new URL(adresse).origin;
40
+ const origineDeLHotePublic = adressePublique ? new URL(adressePublique).origin : undefined;
41
+ const hotePublic = adressePublique ? new URL(adressePublique).host : undefined;
42
+ // Les choses changées depuis leur dernière écriture, et celles qui ne s'écrivent plus, pleines.
43
+ const changees = new Set();
44
+ const pleines = new Set();
45
+ // Chaque WebSocket ouvert, et s'il a répondu au dernier ping.
46
+ const vivants = new Map();
47
+ // Les derniers présents signalés de chaque chose, et leurs signaux, l'un après l'autre.
48
+ const presentsSignales = new Map();
49
+ const filesDesPresents = new Map();
50
+ let enFermeture = false;
51
+ // Le droit d'une connexion sur la chose qu'elle demande, ou son refus. Sous le domaine : son
52
+ // origine est celle d'ADRESSE, la personne est connectée au core, et son droit sur la chose. Sur
53
+ // l'hôte public : son origine est celle d'ADRESSE_PUBLIQUE, et la chose est publiée.
54
+ async function droitDe(entree, chose, jeton) {
55
+ if (chose !== entree.chose) {
56
+ throw refuser(raisons.introuvable);
57
+ }
58
+ if (entree.publique) {
59
+ if (entree.origine !== origineDeLHotePublic) {
60
+ throw refuser(raisons.origine);
61
+ }
62
+ const publiee = await reglages.estPubliee(chose).catch(() => {
63
+ throw refuser(raisons.reessayez);
64
+ });
65
+ if (!publiee) {
66
+ throw refuser(raisons.plusOuvert);
67
+ }
68
+ return { droit: 'modification', personne: personneDeLInvite(jeton === undefined ? undefined : lireLeJeton(jeton), randomUUID) };
69
+ }
70
+ if (entree.origine !== origineDuDomaine) {
71
+ throw refuser(raisons.origine);
72
+ }
73
+ const personne = await session.personneDuGeste({ headers: { cookie: entree.cookie } }).catch(() => {
74
+ throw refuser(raisons.reessayez);
75
+ });
76
+ if (!personne) {
77
+ throw refuser(raisons.connexion);
78
+ }
79
+ if (personne === 'fermee') {
80
+ throw refuser(raisons.introuvable);
81
+ }
82
+ const droit = await reglages.droitDe(personne, chose).catch(() => {
83
+ throw refuser(raisons.reessayez);
84
+ });
85
+ if (!droit) {
86
+ throw refuser(raisons.introuvable);
87
+ }
88
+ return {
89
+ droit: suffit(droit, 'modification') ? 'modification' : 'lecture',
90
+ personne: { id: personne.id, nom: Array.from(personne.nom).slice(0, longueurDUnNom).join('') },
91
+ };
92
+ }
93
+ // Les présents d'une chose : une fois chaque personne connectée, par son nom puis son identifiant.
94
+ function presentsDe(document) {
95
+ const presents = new Map();
96
+ for (const connexion of document.getConnections()) {
97
+ const personne = connexion.context.personne;
98
+ if (personne && !presents.has(personne.id)) {
99
+ presents.set(personne.id, personne);
100
+ }
101
+ }
102
+ return [...presents.values()].sort((une, autre) => une.nom.localeCompare(autre.nom, 'fr') || une.id.localeCompare(autre.id));
103
+ }
104
+ // Signale les présents d'une chose, s'ils ont changé, dans l'ordre des changements.
105
+ function signalerLesPresents(chose, presents) {
106
+ const quand = reglages.quandLesPresentsChangent;
107
+ if (!quand) {
108
+ return;
109
+ }
110
+ const signature = JSON.stringify(presents);
111
+ if ((presentsSignales.get(chose) ?? '[]') === signature) {
112
+ return;
113
+ }
114
+ if (presents.length) {
115
+ presentsSignales.set(chose, signature);
116
+ }
117
+ else {
118
+ presentsSignales.delete(chose);
119
+ }
120
+ const suite = (filesDesPresents.get(chose) ?? Promise.resolve())
121
+ .then(() => quand(chose, presents))
122
+ .catch((erreur) => console.error(erreur));
123
+ filesDesPresents.set(chose, suite);
124
+ void suite.then(() => {
125
+ if (filesDesPresents.get(chose) === suite) {
126
+ filesDesPresents.delete(chose);
127
+ }
128
+ });
129
+ }
130
+ // Une chose pleine ne s'écrit plus : elle passe en lecture seule pour tous, et chaque page le sait.
131
+ function remplir(document) {
132
+ pleines.add(document.name);
133
+ for (const connexion of document.getConnections()) {
134
+ connexion.readOnly = true;
135
+ }
136
+ document.broadcastStateless(JSON.stringify({ plein: true }));
137
+ }
138
+ // Écrit l'état d'une chose en base, s'il a changé et tient dans la limite.
139
+ async function ecrireEnBase(chose, document) {
140
+ if (!changees.has(chose) || pleines.has(chose)) {
141
+ return;
142
+ }
143
+ changees.delete(chose);
144
+ const etat = Y.encodeStateAsUpdate(document);
145
+ if (etat.length > limite) {
146
+ remplir(document);
147
+ return;
148
+ }
149
+ try {
150
+ await reglages.enregistrer(chose, etat, document);
151
+ }
152
+ catch (erreur) {
153
+ changees.add(chose);
154
+ throw erreur;
155
+ }
156
+ }
157
+ // Les clients Yjs des autres connexions d'une chose.
158
+ function clientsDesAutres(document, connexion) {
159
+ const autres = new Set();
160
+ for (const autre of document.getConnections()) {
161
+ if (autre !== connexion) {
162
+ for (const client of document.getClients(autre)) {
163
+ autres.add(client);
164
+ }
165
+ }
166
+ }
167
+ return autres;
168
+ }
169
+ const hocuspocus = new Hocuspocus({
170
+ quiet: true,
171
+ debounce: reglages.delais?.debounce ?? 1000,
172
+ maxDebounce: reglages.delais?.maxDebounce ?? 10_000,
173
+ unloadImmediately: true,
174
+ async onAuthenticate({ context, documentName, connectionConfig, token }) {
175
+ if (!context.entree) {
176
+ throw refuser(raisons.introuvable);
177
+ }
178
+ const { droit, personne } = await droitDe(context.entree, documentName, token);
179
+ connectionConfig.readOnly = droit === 'lecture' || pleines.has(documentName);
180
+ return { droit, personne };
181
+ },
182
+ async connected({ documentName, connection, instance }) {
183
+ if (pleines.has(documentName)) {
184
+ connection.sendStateless(JSON.stringify({ plein: true }));
185
+ }
186
+ const document = instance.documents.get(documentName);
187
+ if (document) {
188
+ signalerLesPresents(documentName, presentsDe(document));
189
+ }
190
+ },
191
+ async onDisconnect({ documentName, instance }) {
192
+ const document = instance.documents.get(documentName);
193
+ signalerLesPresents(documentName, document ? presentsDe(document) : []);
194
+ },
195
+ async onLoadDocument({ documentName }) {
196
+ const etat = await reglages.charger(documentName);
197
+ if (!etat) {
198
+ throw refuser(raisons.introuvable);
199
+ }
200
+ return etat;
201
+ },
202
+ async onChange({ documentName }) {
203
+ changees.add(documentName);
204
+ },
205
+ async onStoreDocument({ documentName, document }) {
206
+ await ecrireEnBase(documentName, document);
207
+ },
208
+ async afterUnloadDocument({ documentName }) {
209
+ pleines.delete(documentName);
210
+ changees.delete(documentName);
211
+ signalerLesPresents(documentName, []);
212
+ await reglages.apresLaFermeture?.(documentName).catch((erreur) => console.error(erreur));
213
+ },
214
+ // La présence d'un onglet : le serveur y écrit la personne de sa connexion (`personne`), et le
215
+ // nom et la couleur que lisent les extensions de Yjs (`user`, comme le curseur de Tiptap) ; une
216
+ // page ne touche ni à la présence d'un client d'une autre connexion, ni à son retrait.
217
+ async beforeHandleAwareness({ states, context, connection, document, removedClients }) {
218
+ if (!connection) {
219
+ return;
220
+ }
221
+ const personne = context?.personne;
222
+ const autres = clientsDesAutres(document, connection);
223
+ for (const [client, etat] of [...states]) {
224
+ if (!personne || autres.has(client)) {
225
+ states.delete(client);
226
+ continue;
227
+ }
228
+ etat.personne = { ...personne };
229
+ etat.user = { name: personne.nom, color: couleurDe(personne.id) };
230
+ }
231
+ for (const client of [...removedClients]) {
232
+ if (autres.has(client)) {
233
+ removedClients.delete(client);
234
+ }
235
+ }
236
+ },
237
+ });
238
+ // Un WebSocket accepté, confié à Hocuspocus. Un message trop grand le ferme (`maxPayload`, 1009).
239
+ const serveurDesSockets = new WebSocketServer({ noServer: true, maxPayload: tailleMaximaleDUnMessage });
240
+ function brancher(socket, entree) {
241
+ const client = hocuspocus.handleConnection(socket, new Request(origineDuDomaine), { entree, socket });
242
+ vivants.set(socket, true);
243
+ socket.on('pong', () => vivants.set(socket, true));
244
+ socket.on('message', (donnees) => {
245
+ const octets = Array.isArray(donnees) ? Buffer.concat(donnees) : Buffer.from(donnees);
246
+ client.handleMessage(new Uint8Array(octets.buffer, octets.byteOffset, octets.byteLength));
247
+ });
248
+ socket.on('close', (code, raison) => {
249
+ vivants.delete(socket);
250
+ client.handleClose({ code, reason: raison.toString() });
251
+ });
252
+ socket.on('error', () => socket.terminate());
253
+ }
254
+ // Un ping toutes les 25 secondes ; un WebSocket qui n'a pas répondu au précédent est coupé.
255
+ const battement = setInterval(() => {
256
+ for (const [socket, vivant] of vivants) {
257
+ if (!vivant) {
258
+ socket.terminate();
259
+ }
260
+ else {
261
+ vivants.set(socket, false);
262
+ socket.ping();
263
+ }
264
+ }
265
+ }, delaiDuBattement);
266
+ battement.unref();
267
+ // Relit le droit de chaque connexion aux choses données, à toutes sans elles : une connexion qui
268
+ // n'a plus de droit est coupée (4403), avec sa raison ; une connexion dont le droit a changé est
269
+ // coupée (4205) pour que la page se reconnecte au nouveau. Un core ou une base qui ne répondent
270
+ // pas laissent la connexion ouverte.
271
+ async function relire(...choses) {
272
+ const visees = choses.length ? new Set(choses) : undefined;
273
+ for (const document of [...hocuspocus.documents.values()]) {
274
+ if (visees && !visees.has(document.name)) {
275
+ continue;
276
+ }
277
+ for (const connexion of document.getConnections()) {
278
+ const { entree, socket, droit } = connexion.context;
279
+ if (!entree || !socket) {
280
+ continue;
281
+ }
282
+ try {
283
+ if ((await droitDe(entree, document.name)).droit !== droit) {
284
+ socket.close(codes.droitChange, 'Reset Connection');
285
+ }
286
+ }
287
+ catch (erreur) {
288
+ const raison = erreur.reason;
289
+ if (raison !== raisons.reessayez) {
290
+ socket.close(codes.plusDeDroit, raison ?? raisons.introuvable);
291
+ }
292
+ }
293
+ }
294
+ }
295
+ }
296
+ const relecture = setInterval(() => {
297
+ relire().catch((erreur) => console.error(erreur));
298
+ }, delaiDeRelecture);
299
+ relecture.unref();
300
+ return {
301
+ hocuspocus,
302
+ // Relit le droit des connexions, aussitôt après un partage, un don, une publication ou une
303
+ // suppression : `relire(id)`, `relire(...ids)`, ou `relire()` pour toutes.
304
+ relire,
305
+ // Écoute les WebSocket du serveur de l'app : `direct/<id>`, avec ou sans le chemin de l'app,
306
+ // sous le domaine comme sur l'hôte public ; tout autre chemin est refusé (404), et l'app qui
307
+ // s'arrête refuse tout (503).
308
+ accueillir(serveur) {
309
+ serveur.on('upgrade', (requete, prise, tete) => {
310
+ let chemin = new URL(requete.url ?? '/', 'http://direct').pathname;
311
+ if (prefixe && chemin.startsWith(`${prefixe}/`)) {
312
+ chemin = chemin.slice(prefixe.length);
313
+ }
314
+ const [, chose] = cheminDUnDirect.exec(chemin) ?? [];
315
+ if (!chose || enFermeture || requete.headers.upgrade?.toLowerCase() !== 'websocket') {
316
+ prise.end(`HTTP/1.1 ${enFermeture ? '503 Service Unavailable' : '404 Not Found'}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
317
+ return;
318
+ }
319
+ serveurDesSockets.handleUpgrade(requete, prise, tete, (socket) => brancher(socket, {
320
+ chose: chose.toLowerCase(),
321
+ publique: hotePublic !== undefined && requete.headers.host === hotePublic,
322
+ origine: requete.headers.origin,
323
+ cookie: requete.headers.cookie,
324
+ }));
325
+ });
326
+ },
327
+ // Le document Yjs d'une chose, pour le lire : celui qui est ouvert, sinon l'état de la base ;
328
+ // rien pour une chose absente. Le lire ne l'écrit pas.
329
+ async lire(chose) {
330
+ const ouvert = hocuspocus.documents.get(chose);
331
+ if (ouvert && !ouvert.isLoading) {
332
+ return ouvert;
333
+ }
334
+ const etat = await reglages.charger(chose);
335
+ if (!etat) {
336
+ return undefined;
337
+ }
338
+ const document = new Y.Doc();
339
+ Y.applyUpdate(document, etat);
340
+ return document;
341
+ },
342
+ // Une écriture de Claude, par le document en direct : elle apparaît aussitôt chez ceux qui ont
343
+ // ouvert la chose, sous une origine que l'historique d'une page ne suit pas (⌘Z ne la défait
344
+ // pas chez les autres) ; puis la connexion directe se ferme et la chose s'écrit en base.
345
+ // `geste` lit le document, vérifie tout, puis écrit : il s'essaie d'abord sur une copie, et ce
346
+ // qu'il lève, ou un état qui passerait la limite, n'écrit rien ; puis il s'applique au document
347
+ // en direct, lu et écrit dans la même transaction, sans attente entre les deux.
348
+ // `avant`, facultatif, se fait la chose ouverte, avant l'essai. `garder`, facultatif, garde
349
+ // l'état d'avant l'écriture, une fois l'essai passé, et rend ce qui le retire si l'écriture
350
+ // échoue.
351
+ async ecrire(chose, geste, options = {}) {
352
+ if (pleines.has(chose)) {
353
+ throw new Refus(reglages.textes.plein);
354
+ }
355
+ // Une chose supprimée entre la vérification de l'outil et l'écriture n'a plus d'état.
356
+ const connexion = await hocuspocus.openDirectConnection(chose, {}).catch((erreur) => {
357
+ throw erreur.reason === raisons.introuvable ? new Refus(reglages.textes.absente(chose)) : erreur;
358
+ });
359
+ let resultat;
360
+ try {
361
+ await options.avant?.();
362
+ const copie = new Y.Doc();
363
+ Y.applyUpdate(copie, Y.encodeStateAsUpdate(connexion.document));
364
+ geste(copie);
365
+ if (Y.encodeStateAsUpdate(copie).length > limite) {
366
+ throw new Refus(reglages.textes.plein);
367
+ }
368
+ const retirer = await options.garder?.(Y.encodeStateAsUpdate(connexion.document));
369
+ try {
370
+ await connexion.transact((document) => {
371
+ resultat = geste(document);
372
+ });
373
+ }
374
+ catch (erreur) {
375
+ await retirer?.().catch((autre) => console.error(autre));
376
+ throw erreur;
377
+ }
378
+ changees.add(chose);
379
+ }
380
+ finally {
381
+ await connexion.disconnect();
382
+ }
383
+ return resultat;
384
+ },
385
+ // La chose est pleine : elle ne s'écrit plus.
386
+ estPleine: (chose) => pleines.has(chose),
387
+ // La chose est ouverte, ou s'ouvre : quelqu'un la tient en mémoire.
388
+ estOuverte: (chose) => hocuspocus.documents.has(chose) || hocuspocus.loadingDocuments.has(chose),
389
+ // Les présents de chaque chose ouverte, pour un flux qui s'ouvre.
390
+ presences() {
391
+ return [...hocuspocus.documents.values()]
392
+ .map((document) => ({ chose: document.name, presents: presentsDe(document) }))
393
+ .filter((presence) => presence.presents.length > 0);
394
+ },
395
+ // À l'arrêt de l'app (`avantDeQuitter`) : écrit les choses ouvertes, puis ferme les connexions
396
+ // (1012), que les pages rouvrent seules au redémarrage.
397
+ async fermer() {
398
+ enFermeture = true;
399
+ clearInterval(battement);
400
+ clearInterval(relecture);
401
+ for (const document of [...hocuspocus.documents.values()]) {
402
+ await ecrireEnBase(document.name, document).catch((erreur) => console.error(erreur));
403
+ }
404
+ for (const socket of vivants.keys()) {
405
+ socket.close(codes.redemarrage, 'Redémarrage');
406
+ }
407
+ // Les écritures en attente n'ont plus rien à écrire : leurs minuteries ne retiennent pas l'app.
408
+ hocuspocus.flushPendingStores();
409
+ },
410
+ };
411
+ }
@@ -70,6 +70,11 @@ export type DeclarationDesChoses<C extends ChoseTrouvee = ChoseTrouvee> = {
70
70
  app: string;
71
71
  une: string;
72
72
  feminin?: boolean;
73
+ liste?: {
74
+ titre: string;
75
+ chemin: string;
76
+ };
77
+ sorte?: string;
73
78
  colonnes?: ColonneDUneChose<C>[];
74
79
  vues?: VueDeLaListe[];
75
80
  etat?: (chose: C) => ReactNode;
@@ -145,4 +150,8 @@ export declare function motsDe(declaration: {
145
150
  pronom: string;
146
151
  };
147
152
  export declare function cleDesChoses(app: string, ...suite: unknown[]): unknown[];
153
+ export declare function cleDUneChose(choses: {
154
+ app: string;
155
+ sorte?: string;
156
+ }, ...suite: unknown[]): unknown[];
148
157
  export declare function useRelireLesChoses(app: string): () => Promise<void>;
@@ -89,6 +89,11 @@ export function motsDe(declaration) {
89
89
  export function cleDesChoses(app, ...suite) {
90
90
  return ['choses', app, ...suite];
91
91
  }
92
+ // La clé d'une chose lue (`'chose'`) ou de son partage (`'partage'`), sous sa sorte quand l'app en
93
+ // déclare une : deux choses de sortes différentes et de même identifiant ne se mêlent pas.
94
+ export function cleDUneChose(choses, ...suite) {
95
+ return cleDesChoses(choses.app, ...(choses.sorte ? [choses.sorte] : []), ...suite);
96
+ }
92
97
  // Relire la liste et les choses d'une app, après un geste propre de l'app qui les change (une
93
98
  // facture émise passe d'une vue à l'autre).
94
99
  export function useRelireLesChoses(app) {
@@ -68,12 +68,15 @@ function LigneDuHaut({ ecran, surUneChose, setFin, setGestes }) {
68
68
  const session = useSession();
69
69
  const ici = useLocation({ select: (lieu) => lieu.pathname });
70
70
  const cadre = cadreDe(session, ici);
71
+ // Sur l'écran d'une chose dont la déclaration nomme sa liste (`liste`), elle remplace l'onglet.
72
+ const liste = useMatches({ select: (routes) => routes.find((route) => route.staticData?.choses)?.staticData?.choses?.liste });
73
+ const debut = liste && cadre.app ? [...cadre.debut.slice(0, 1), liste] : cadre.debut;
71
74
  // Le nom de l'épingle : celui de l'onglet, sinon celui que l'écran a déclaré ; tant qu'il manque,
72
75
  // comme pendant la lecture d'une chose, l'épingle reste inactive. Une chose introuvable ne
73
76
  // montre l'épingle que si son chemin est déjà dans la barre, pour la retirer.
74
77
  const nomDeLEpingle = cadre.nomDeLEpingle ?? ecran.nom;
75
78
  const epingleMontree = sEpingle(session, ici) && (!ecran.introuvable || estEpingle(session.barre, ici));
76
- return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "flex min-h-9 flex-wrap items-center justify-between gap-x-4 gap-y-2 max-[760px]:flex-col max-[760px]:items-stretch", children: [_jsxs("nav", { "aria-label": "Fil d'Ariane", className: "flex min-h-9 min-w-0 items-center gap-2 text-[15px]", children: [cadre.debut.map((segment, rang) => (_jsxs("span", { className: "contents", children: [_jsx(LienDansLaPage, { href: segment.chemin, className: "flex-none font-medium whitespace-nowrap text-gris no-underline hover:text-encre max-[760px]:hidden", children: segment.titre }), separateurDuFil] }, rang))), _jsx("div", { ref: setFin, className: "contents" }), epingleMontree && _jsx(EpingleDuCadre, { chemin: ici, nom: nomDeLEpingle }, ici)] }), _jsx("div", { ref: setGestes, className: "flex flex-wrap items-center gap-2 empty:hidden" })] }), cadre.app && !surUneChose && cadre.onglets.length > 0 && (_jsx("nav", { "aria-label": "Onglets", className: "mt-1.5 flex flex-wrap gap-x-6 border-b border-trait", children: cadre.onglets.map((onglet) => (_jsx(LienDansLaPage, { href: onglet.chemin, "aria-current": onglet.chemin === cadre.actif?.chemin ? 'page' : undefined, className: "-mb-px border-b-2 border-transparent pt-1 pb-2.5 font-medium text-gris no-underline hover:text-encre aria-[current=page]:border-accent aria-[current=page]:text-encre", children: onglet.titre }, onglet.chemin))) })), surUneChose && _jsx("div", { className: "mt-2.5 border-b border-trait" })] }));
79
+ return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "flex min-h-9 flex-wrap items-center justify-between gap-x-4 gap-y-2 max-[760px]:flex-col max-[760px]:items-stretch", children: [_jsxs("nav", { "aria-label": "Fil d'Ariane", className: "flex min-h-9 min-w-0 items-center gap-2 text-[15px]", children: [debut.map((segment, rang) => (_jsxs("span", { className: "contents", children: [_jsx(LienDansLaPage, { href: segment.chemin, className: "flex-none font-medium whitespace-nowrap text-gris no-underline hover:text-encre max-[760px]:hidden", children: segment.titre }), separateurDuFil] }, rang))), _jsx("div", { ref: setFin, className: "contents" }), epingleMontree && _jsx(EpingleDuCadre, { chemin: ici, nom: nomDeLEpingle }, ici)] }), _jsx("div", { ref: setGestes, className: "flex flex-wrap items-center gap-2 empty:hidden" })] }), cadre.app && !surUneChose && cadre.onglets.length > 0 && (_jsx("nav", { "aria-label": "Onglets", className: "mt-1.5 flex flex-wrap gap-x-6 border-b border-trait", children: cadre.onglets.map((onglet) => (_jsx(LienDansLaPage, { href: onglet.chemin, "aria-current": onglet.chemin === cadre.actif?.chemin ? 'page' : undefined, className: "-mb-px border-b-2 border-transparent pt-1 pb-2.5 font-medium text-gris no-underline hover:text-encre aria-[current=page]:border-accent aria-[current=page]:text-encre", children: onglet.titre }, onglet.chemin))) })), surUneChose && _jsx("div", { className: "mt-2.5 border-b border-trait" })] }));
77
80
  }
78
81
  // L'épingle au bout du fil, pour le chemin de la page, sans sa recherche : grise, pleine à l'accent
79
82
  // quand il est dans la barre de la personne, qui l'y ajoute ou l'en retire (`useEpingle`). Sans nom,
@@ -0,0 +1,5 @@
1
+ export declare function useAnnoncerLeDroitQuiBaisse(lecture: boolean | undefined, chose: {
2
+ une: string;
3
+ feminin?: boolean;
4
+ }): void;
5
+ export declare function useMontrerLaChoseIntrouvable(app: string): (id: string) => void;
@@ -0,0 +1,37 @@
1
+ import { useQueryClient } from '@tanstack/react-query';
2
+ import { useCallback, useEffect, useRef } from 'react';
3
+ import { texteDuDroitQuiBaisse } from '../ui/direct.js';
4
+ import { cleDesChoses } from './choses.js';
5
+ import { useAnnoncer } from './ouvrir.js';
6
+ // Les gestes du direct dans l'écran d'une chose (bibliotheque/CLAUDE.md, « Le direct à l'écran ») :
7
+ // le droit qui baisse se dit une fois, la chose fermée devient l'écran d'une chose introuvable, et la
8
+ // session fermée recharge la page (`rechargerLaPage`, de ./navigation.ts).
9
+ // Annonce le droit qui baisse : quand `lecture`, ce que le direct dit du droit de la personne, passe
10
+ // de faux à vrai, une annonce, « Ce tableau ne vous est plus ouvert qu'en lecture. ». Une chose qui
11
+ // s'ouvre déjà en lecture ne dit rien. `undefined`, un droit pas encore lu (pendant une connexion),
12
+ // ne compte pas : le dernier droit connu reste celui d'avant.
13
+ export function useAnnoncerLeDroitQuiBaisse(lecture, chose) {
14
+ const annoncer = useAnnoncer();
15
+ const connu = useRef(undefined);
16
+ const { une, feminin } = chose;
17
+ useEffect(() => {
18
+ if (lecture === undefined) {
19
+ return;
20
+ }
21
+ if (connu.current === false && lecture) {
22
+ annoncer(texteDuDroitQuiBaisse(une, feminin));
23
+ }
24
+ connu.current = lecture;
25
+ }, [lecture, annoncer, une, feminin]);
26
+ }
27
+ // Rend la fonction qui montre l'écran commun d'une chose introuvable à la place de la chose `id`,
28
+ // quand le direct dit qu'elle n'existe plus ou n'est plus ouverte à la personne : le même écran
29
+ // qu'à l'ouverture d'un lien vers une chose fermée (`texteDUneChoseAbsente`).
30
+ export function useMontrerLaChoseIntrouvable(app) {
31
+ const client = useQueryClient();
32
+ return useCallback((id) => {
33
+ const cle = cleDesChoses(app, 'chose', id);
34
+ void client.cancelQueries({ queryKey: cle });
35
+ client.setQueryData(cle, null);
36
+ }, [client, app]);
37
+ }
@@ -1,5 +1,8 @@
1
+ import { type ReactNode } from 'react';
1
2
  import { type ChoseTrouvee, type DeclarationDesChoses } from './choses.ts';
2
- export declare const texteDUneChoseAbsente = "Cette chose n'existe pas, ou vous n'y avez pas acc\u00E8s.";
3
+ export declare function DansLEtatDuDirect({ children }: {
4
+ children: ReactNode;
5
+ }): import("react").ReactPortal | null;
3
6
  export declare function EcranDUneChose<C extends ChoseTrouvee>({ choses, id }: {
4
7
  choses: DeclarationDesChoses<C>;
5
8
  id: string;
@@ -1,14 +1,15 @@
1
1
  import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
2
2
  import { useQuery } from '@tanstack/react-query';
3
- import { useRef, useState } from 'react';
3
+ import { createContext, useContext, useRef, useState } from 'react';
4
+ import { createPortal } from 'react-dom';
4
5
  import { Message } from '../ui/blocs.js';
5
6
  import { cn } from '../ui/classes.js';
6
7
  import { Bouton } from '../ui/bouton.js';
7
- import { EtatDeLecture } from '../ui/etats.js';
8
+ import { EtatDeLecture, texteDUneChoseAbsente } from '../ui/etats.js';
8
9
  import { Lien } from '../ui/lien.js';
9
10
  import { ErreurDUnAppel } from './appels.js';
10
11
  import { classesDuTitre, DansLeFil, DansLesGestes, separateurDuFil, TitreDuFil, useDeclarerLEcran } from './cadre.js';
11
- import { cleDesChoses, motsDe, useRelireLesChoses } from './choses.js';
12
+ import { cleDUneChose, motsDe, useRelireLesChoses } from './choses.js';
12
13
  import { ModifierLaFiche } from './formulaire-d-une-fiche.js';
13
14
  import { MenuDUneChose } from './menu-d-une-chose.js';
14
15
  import { adresseDeLaListe, useAnnoncer, useOuvrir } from './ouvrir.js';
@@ -17,10 +18,11 @@ import { useSession } from './session.js';
17
18
  // L'écran d'une chose, dans le cadre de la coquille (docs/architecture.md, « L'espace ») : le fil
18
19
  // d'Ariane « <app> / <liste> / <nom> », que la coquille commence et que l'écran finit par les
19
20
  // ancêtres d'une chose rangée dans une autre, le nom, qui se renomme d'un clic, et la pastille de
20
- // l'accès ; ses gestes en haut à droite, dans leur ordre : le geste propre de l'app, ou « Modifier »
21
- // pour une fiche qui n'en a pas d'autre (`ModifierLaFiche`), la pleine page dans un autre onglet, et
22
- // le ⋯ ; puis le corps, que rend l'app, après l'état de lecture commun. Ni onglets ni étiquette d'état. La
23
- // route pose `staticData: { ecranDUneChose: true, choses }` (`routesDesChoses`) : la coquille y lit la
21
+ // l'accès ; ses gestes en haut à droite, dans leur ordre : l'état du direct d'une chose qu'on écrit
22
+ // à plusieurs (`DansLEtatDuDirect`), le geste propre de l'app, ou « Modifier » pour une fiche qui
23
+ // n'en a pas d'autre (`ModifierLaFiche`), la pleine page dans un autre onglet, et le ⋯ ; puis le
24
+ // corps, que rend l'app, après l'état de lecture commun. Ni onglets ni étiquette d'état. La route
25
+ // pose `staticData: { ecranDUneChose: true, choses }` (`routesDesChoses`) : la coquille y lit la
24
26
  // déclaration pour la barre de la liste. Le corps est à l'app : un cadre qu'il porte reste isolé, et
25
27
  // rien de ce qu'il envoie ne déclenche un geste du cadre ni du panneau du partage, qui n'écoutent que
26
28
  // leurs boutons.
@@ -28,12 +30,20 @@ import { useSession } from './session.js';
28
30
  function estAbsente(erreur) {
29
31
  return erreur instanceof ErreurDUnAppel && erreur.statut >= 400 && erreur.statut < 500;
30
32
  }
31
- export const texteDUneChoseAbsente = 'Cette chose n\'existe pas, ou vous n\'y avez pas accès.';
33
+ // La place de l'état du direct, en haut à droite, avant le geste propre : le corps d'une chose y
34
+ // rend l'état et les présences (`EtatEtPresences`) par `DansLEtatDuDirect`, d'où que vienne son
35
+ // direct.
36
+ const PlaceDuDirect = createContext(null);
37
+ export function DansLEtatDuDirect({ children }) {
38
+ const place = useContext(PlaceDuDirect);
39
+ return place ? createPortal(children, place) : null;
40
+ }
32
41
  export function EcranDUneChose({ choses, id }) {
33
42
  const session = useSession();
34
43
  const ouvrir = useOuvrir();
44
+ const [placeDuDirect, setPlaceDuDirect] = useState(null);
35
45
  const lecture = useQuery({
36
- queryKey: cleDesChoses(choses.app, 'chose', id),
46
+ queryKey: cleDUneChose(choses, 'chose', id),
37
47
  queryFn: async () => (await choses.lire(id)) ?? null,
38
48
  // Une panne va à l'erreur de l'écran à la première lecture seulement : une relecture qui
39
49
  // échoue (l'app redémarre, le réseau coupe) garde la chose déjà lue, et son corps avec elle.
@@ -50,7 +60,7 @@ export function EcranDUneChose({ choses, id }) {
50
60
  }
51
61
  const pleinePage = choses.pleinePage?.(chose);
52
62
  const ancetres = choses.ancetres?.(chose) ?? [];
53
- return (_jsxs(_Fragment, { children: [_jsx("title", { children: `${chose.nom} · ${session.theme.nom}` }), _jsxs(DansLeFil, { children: [_jsx(AncetresDansLeFil, { ancetres: ancetres }), _jsx(NomDUneChose, { choses: choses, chose: chose }), choses.lirePartage && _jsx(PastilleDeLAcces, { choses: choses, chose: chose })] }), _jsxs(DansLesGestes, { children: [choses.geste ? choses.geste(chose) : _jsx(ModifierLaFiche, { choses: choses, chose: chose }), pleinePage && (_jsx(Bouton, { asChild: true, sorte: "secondaire", children: _jsxs("a", { href: pleinePage, target: "_blank", rel: "noopener noreferrer", children: [choses.libelleDeLaPleinePage ?? 'Pleine page', " \u2197"] }) })), _jsx(MenuDUneChose, { choses: choses, chose: chose, surLEcran: true, surSupprimee: () => ouvrir(ancetres.at(-1)?.chemin ?? adresseDeLaListe(choses.app)) })] }), choses.plein ? _jsx("div", { className: "flex min-h-0 flex-1 flex-col", children: choses.corps(chose) }) : choses.corps(chose)] }));
63
+ return (_jsxs(PlaceDuDirect.Provider, { value: placeDuDirect, children: [_jsx("title", { children: `${chose.nom} · ${session.theme.nom}` }), _jsxs(DansLeFil, { children: [_jsx(AncetresDansLeFil, { ancetres: ancetres }), _jsx(NomDUneChose, { choses: choses, chose: chose }), choses.lirePartage && _jsx(PastilleDeLAcces, { choses: choses, chose: chose })] }), _jsxs(DansLesGestes, { children: [_jsx("span", { ref: setPlaceDuDirect, className: "contents" }), choses.geste ? choses.geste(chose) : _jsx(ModifierLaFiche, { choses: choses, chose: chose }), pleinePage && (_jsx(Bouton, { asChild: true, sorte: "secondaire", children: _jsxs("a", { href: pleinePage, target: "_blank", rel: "noopener noreferrer", children: [choses.libelleDeLaPleinePage ?? 'Pleine page', " \u2197"] }) })), _jsx(MenuDUneChose, { choses: choses, chose: chose, surLEcran: true, surSupprimee: () => ouvrir(ancetres.at(-1)?.chemin ?? choses.liste?.chemin ?? adresseDeLaListe(choses.app)) })] }), choses.plein ? _jsx("div", { className: "flex min-h-0 flex-1 flex-col", children: choses.corps(chose) }) : choses.corps(chose)] }));
54
64
  }
55
65
  // Les ancêtres d'une chose rangée dans une autre, chacun un lien ; au-delà de deux, le premier et
56
66
  // « … ».
@@ -0,0 +1,37 @@
1
+ import { type AnyRoute } from '@tanstack/react-router';
2
+ import type { AppOuverte, Session } from './session.ts';
3
+ export declare function appDEssai(nom: string, titre: string, { ecrans, reglages }?: {
4
+ ecrans?: {
5
+ nom: string;
6
+ titre: string;
7
+ }[];
8
+ reglages?: boolean;
9
+ }): AppOuverte;
10
+ export declare function sessionDEssai(apps?: AppOuverte[], autres?: Partial<Session>): Session;
11
+ export declare function resultat(valeur: unknown, enErreur?: boolean): {
12
+ content: {
13
+ type: string;
14
+ text: string;
15
+ }[];
16
+ isError?: boolean | undefined;
17
+ };
18
+ export type Reponse = [statut: number, corps: unknown];
19
+ export type AppelRecu = {
20
+ chemin: string;
21
+ methode: string;
22
+ corps: any;
23
+ };
24
+ export declare function servir(routes: Record<string, (corps: any) => Reponse | Promise<Reponse>>): AppelRecu[];
25
+ export declare function ouvrirLaPage(adresse: string, ecrans: AnyRoute[], options?: {
26
+ nom?: string;
27
+ version?: string;
28
+ etat?: Record<string, unknown> | null;
29
+ }): {
30
+ router: import("@tanstack/router-core").RouterCore<import("@tanstack/router-core").Route<import("@tanstack/react-router").Register, any, "/", "/", string, "__root__", undefined, {}, import("./page.tsx").ContexteDuRouteur, import("@tanstack/react-router").AnyContext, ({ context }: import("@tanstack/react-router").BeforeLoadContextOptions<import("@tanstack/react-router").Register, any, undefined, {}, import("./page.tsx").ContexteDuRouteur, import("@tanstack/react-router").AnyContext, "__root__", unknown, undefined>) => Promise<undefined> | undefined, {}, undefined, readonly [import("@tanstack/router-core").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/react-router").Register, undefined, import("./page.tsx").ContexteDuRouteur, import("@tanstack/react-router").AnyContext, ({ context }: import("@tanstack/react-router").BeforeLoadContextOptions<import("@tanstack/react-router").Register, any, undefined, {}, import("./page.tsx").ContexteDuRouteur, import("@tanstack/react-router").AnyContext, "__root__", unknown, undefined>) => Promise<undefined> | undefined, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "/", "/", "coquille-de-l-espace", "/coquille-de-l-espace", undefined, import("@tanstack/react-router").ResolveParams<"/">, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, {}, undefined, AnyRoute[], unknown, unknown, unknown, undefined>, import("@tanstack/router-core").Route<unknown, import("@tanstack/react-router").RootRoute<import("@tanstack/react-router").Register, undefined, import("./page.tsx").ContexteDuRouteur, import("@tanstack/react-router").AnyContext, ({ context }: import("@tanstack/react-router").BeforeLoadContextOptions<import("@tanstack/react-router").Register, any, undefined, {}, import("./page.tsx").ContexteDuRouteur, import("@tanstack/react-router").AnyContext, "__root__", unknown, undefined>) => Promise<undefined> | undefined, {}, undefined, unknown, unknown, unknown, unknown, undefined>, "/", "/", "hors-de-la-coquille", "/hors-de-la-coquille", undefined, import("@tanstack/react-router").ResolveParams<"/">, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, {}, undefined, AnyRoute[], unknown, unknown, unknown, undefined>], unknown, unknown, unknown, undefined>, "never", false, import("@tanstack/history").RouterHistory, Record<string, any>>;
31
+ client: import("@tanstack/query-core").QueryClient;
32
+ demonter: () => void;
33
+ };
34
+ export declare function testerLEcranDesComptes(app: {
35
+ nom: string;
36
+ titre: string;
37
+ }, ecrans?: AnyRoute[]): void;