@indos/bibliotheque 1.12.0 → 2.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.
Files changed (68) hide show
  1. package/CHANGELOG.md +50 -0
  2. package/package.json +33 -2
  3. package/src/app.js +7 -12
  4. package/src/direct/page.d.ts +33 -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/apercu.d.ts +9 -0
  9. package/src/espace/apercu.js +105 -0
  10. package/src/espace/cadre.d.ts +12 -0
  11. package/src/espace/cadre.js +21 -10
  12. package/src/espace/choses.d.ts +28 -7
  13. package/src/espace/choses.js +26 -9
  14. package/src/espace/coquille.d.ts +4 -0
  15. package/src/espace/coquille.js +47 -34
  16. package/src/espace/direct.d.ts +9 -0
  17. package/src/espace/direct.js +20 -4
  18. package/src/espace/ecran-d-une-chose.d.ts +0 -4
  19. package/src/espace/ecran-d-une-chose.js +42 -32
  20. package/src/espace/ecran.d.ts +1 -2
  21. package/src/espace/ecran.js +7 -6
  22. package/src/espace/essai.d.ts +37 -0
  23. package/src/espace/essai.js +117 -0
  24. package/src/espace/formulaire-d-une-fiche.js +4 -5
  25. package/src/espace/index.d.ts +6 -7
  26. package/src/espace/index.js +6 -7
  27. package/src/espace/lien.d.ts +4 -4
  28. package/src/espace/lien.js +3 -5
  29. package/src/espace/liste-des-choses.js +86 -24
  30. package/src/espace/menu-d-une-chose.d.ts +2 -1
  31. package/src/espace/menu-d-une-chose.js +17 -14
  32. package/src/espace/ouvrir.d.ts +1 -4
  33. package/src/espace/ouvrir.js +5 -13
  34. package/src/espace/page.d.ts +0 -2
  35. package/src/espace/page.js +0 -3
  36. package/src/espace/panneau-du-partage.d.ts +9 -8
  37. package/src/espace/panneau-du-partage.js +132 -48
  38. package/src/espace/routes-des-choses.js +2 -2
  39. package/src/faux-core.d.ts +23 -0
  40. package/src/faux-core.js +81 -0
  41. package/src/fichiers-d-une-chose.d.ts +37 -0
  42. package/src/fichiers-d-une-chose.js +136 -0
  43. package/src/forme-du-direct.d.ts +29 -0
  44. package/src/forme-du-direct.js +70 -0
  45. package/src/partage.d.ts +7 -2
  46. package/src/partage.js +26 -7
  47. package/src/presence.d.ts +6 -0
  48. package/src/presence.js +6 -3
  49. package/src/remplacements.d.ts +26 -0
  50. package/src/remplacements.js +41 -0
  51. package/src/sans-le-chemin.d.ts +1 -0
  52. package/src/sans-le-chemin.js +9 -0
  53. package/src/signaux.d.ts +5 -0
  54. package/src/signaux.js +20 -0
  55. package/src/ui/direct.d.ts +7 -6
  56. package/src/ui/direct.js +26 -4
  57. package/src/ui/icones.d.ts +6 -0
  58. package/src/ui/icones.js +8 -0
  59. package/src/ui/index.d.ts +2 -2
  60. package/src/ui/index.js +2 -2
  61. package/src/ui/menu-d-une-ligne.js +1 -1
  62. package/src/ui/tableau.d.ts +3 -1
  63. package/src/ui/tableau.js +10 -5
  64. package/src/vite.js +4 -2
  65. package/src/espace/barre-de-la-liste.d.ts +0 -6
  66. package/src/espace/barre-de-la-liste.js +0 -78
  67. package/src/espace/heure.d.ts +0 -1
  68. package/src/espace/heure.js +0 -6
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
+ }
@@ -0,0 +1,9 @@
1
+ import type { ChoseTrouvee, DeclarationDesChoses } from './choses.ts';
2
+ export declare function ApercuDUneChose<C extends ChoseTrouvee>({ choses, id, chemin: cheminDeLaLigne, fermer, passer, quitter }: {
3
+ choses: DeclarationDesChoses<C>;
4
+ id: string;
5
+ chemin?: string;
6
+ fermer: () => void;
7
+ passer: (sens: 1 | -1) => void;
8
+ quitter: () => void;
9
+ }): import("react").JSX.Element;
@@ -0,0 +1,105 @@
1
+ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
2
+ import { useEffect, useMemo, useRef, useState } from 'react';
3
+ import { IconeAgrandir, IconeFermer } from '../ui/icones.js';
4
+ import { ContexteDuCadre } from './cadre.js';
5
+ import { EpingleDuCadre } from './coquille.js';
6
+ import { EcranDUneChose } from './ecran-d-une-chose.js';
7
+ import { LienDansLaPage } from './lien.js';
8
+ import { useOuvrir } from './ouvrir.js';
9
+ // L'aperçu d'une chose, par-dessus sa liste (docs/architecture.md, « L'espace ») : l'écran de la
10
+ // chose, le même, en étroit, dans un panneau posé à droite de la zone de l'écran, sur toute sa
11
+ // hauteur, ligne du haut comprise, une ombre sur son bord gauche, sans voile : la liste reste
12
+ // utilisable et ne bouge pas. 55 % de la zone au plus, 680 px au plus, 380 px au moins ; sous
13
+ // 760 px, tout l'écran. Il apparaît net, sans glisser.
14
+ //
15
+ // Sa tête est celle d'une chose, dans le cadre que le panneau donne à l'écran de la chose : le nom à
16
+ // gauche (un `<h2>`, renommable), puis le bloc de l'accès, l'épingle de la chose, le ⋯, un trait,
17
+ // « Agrandir », qui mène à son écran, et « Fermer ». Son pied dit le clavier : ↑ ↓ passent à la ligne
18
+ // voisine (`passer`), Entrée agrandit, Échap ferme (`toucheDeLApercu`). Le focus va au titre à
19
+ // l'ouverture. La liste tient l'adresse (`apercu`) et le focus qui revient à la ligne.
20
+ // Les icônes de la tête, de 28 px comme l'épingle et le ⋯ ; le survol ne change que la couleur.
21
+ const classesDUneIcone = 'grid size-7 flex-none cursor-pointer place-items-center rounded-md border-0 bg-transparent text-gris no-underline hover:bg-survol hover:text-encre';
22
+ // Le corps de la chose dans l'aperçu, que rend l'app : ses touches restent les siennes.
23
+ const attributDuCorps = 'data-corps-de-l-apercu';
24
+ export function ApercuDUneChose({ choses, id, chemin: cheminDeLaLigne, fermer, passer, quitter }) {
25
+ const ouvrir = useOuvrir();
26
+ const [fin, setFin] = useState(null);
27
+ const [gestes, setGestes] = useState(null);
28
+ const [menu, setMenu] = useState(null);
29
+ const [ecran, setEcran] = useState({});
30
+ // Le cadre ne change qu'avec ses emplacements : `quitter` se lit au moment où la chose part.
31
+ const quitterMaintenant = useRef(quitter);
32
+ quitterMaintenant.current = quitter;
33
+ const cadre = useMemo(() => ({ fin, gestes, menu, declarer: setEcran, apercu: { quitter: () => quitterMaintenant.current() } }), [fin, gestes, menu]);
34
+ const chemin = ecran.introuvable ? undefined : ecran.chemin ?? cheminDeLaLigne;
35
+ // Le focus au titre, une fois la chose lue ou dite introuvable, sans faire défiler la page.
36
+ const focalise = useRef(false);
37
+ useEffect(() => {
38
+ if (focalise.current || !fin || (ecran.nom === undefined && !ecran.introuvable)) {
39
+ return;
40
+ }
41
+ const titre = fin.querySelector('h2');
42
+ if (titre) {
43
+ focalise.current = true;
44
+ titre.focus({ preventScroll: true });
45
+ }
46
+ }, [fin, ecran.nom, ecran.introuvable]);
47
+ useEffect(() => {
48
+ function touche(evenement) {
49
+ const geste = toucheDeLApercu(evenement);
50
+ if (!geste || (geste === 'agrandir' && !chemin)) {
51
+ return;
52
+ }
53
+ evenement.preventDefault();
54
+ if (geste === 'fermer') {
55
+ fermer();
56
+ }
57
+ else if (geste === 'agrandir') {
58
+ ouvrir(chemin);
59
+ }
60
+ else {
61
+ passer(geste === 'suivante' ? 1 : -1);
62
+ }
63
+ }
64
+ document.addEventListener('keydown', touche);
65
+ return () => document.removeEventListener('keydown', touche);
66
+ }, [chemin, fermer, passer, ouvrir]);
67
+ return (_jsx("aside", { "aria-label": "Aper\u00E7u", className: [
68
+ 'absolute inset-y-0 right-0 z-30 w-[min(55%,680px)] min-w-[380px] border-l border-trait bg-papier text-encre shadow-[-16px_0_40px_rgb(0_0_0/0.12)]',
69
+ 'max-[760px]:fixed max-[760px]:inset-0 max-[760px]:w-auto max-[760px]:min-w-0 max-[760px]:border-l-0 max-[760px]:shadow-none',
70
+ ].join(' '), children: _jsxs("div", { className: "sticky top-0 flex h-dvh max-h-full flex-col pt-4 max-[760px]:max-h-none max-[760px]:pt-3", children: [_jsxs("div", { className: "flex min-h-11 flex-none items-center gap-x-3 px-5 shadow-[inset_0_-1px_0_var(--color-trait)] max-[760px]:px-3", children: [_jsx("div", { ref: setFin, className: "flex min-w-0 flex-1 items-center gap-2 text-[15px]" }), _jsxs("div", { className: "flex flex-none items-center gap-1", children: [_jsx("div", { ref: setGestes, className: "flex items-center gap-2 empty:hidden" }), chemin && _jsx(EpingleDuCadre, { chemin: chemin, nom: ecran.nom }, chemin), _jsx("div", { ref: setMenu, className: "flex items-center empty:hidden" }), _jsx("span", { "aria-hidden": "true", className: "mx-1.5 h-[18px] w-px bg-trait" }), chemin && (_jsx(LienDansLaPage, { href: chemin, "aria-label": "Agrandir", title: "Agrandir", className: classesDUneIcone, children: _jsx(IconeAgrandir, {}) })), _jsx("button", { type: "button", "aria-label": "Fermer l'aper\u00E7u", title: "Fermer", onClick: fermer, className: classesDUneIcone, children: _jsx(IconeFermer, {}) })] })] }), _jsx("div", { [attributDuCorps]: '', className: "flex min-h-0 flex-1 flex-col overflow-y-auto px-5 pt-3.5 pb-6 max-[760px]:px-3", children: _jsx(ContexteDuCadre.Provider, { value: cadre, children: _jsx(EcranDUneChose, { choses: choses, id: id }, id) }) }), _jsxs("p", { className: "m-0 flex flex-none flex-wrap items-center gap-x-2 border-t border-trait px-5 py-1.5 text-[12px] text-gris max-[760px]:hidden", children: [_jsxs("span", { children: [_jsx(Touche, { children: "\u2191" }), " ", _jsx(Touche, { children: "\u2193" }), " pr\u00E9c\u00E9dent / suivant"] }), _jsx("span", { "aria-hidden": "true", children: "\u00B7" }), _jsxs("span", { children: [_jsx(Touche, { children: "Entr\u00E9e" }), " agrandir"] }), _jsx("span", { "aria-hidden": "true", children: "\u00B7" }), _jsxs("span", { children: [_jsx(Touche, { children: "\u00C9chap" }), " fermer"] })] })] }) }));
71
+ }
72
+ function Touche({ children }) {
73
+ return _jsx("kbd", { className: "rounded-[4px] border border-b-2 border-trait px-1 font-mono text-[11px]", children: children });
74
+ }
75
+ // Ce qui garde ses touches : un champ, un éditeur, une liste de choix, une fenêtre, un menu, un cadre.
76
+ const champsEtFenetres = [
77
+ 'input', 'textarea', 'select', '[contenteditable]:not([contenteditable=false])', 'iframe',
78
+ '[role=dialog]', '[role=alertdialog]', '[role=menu]', '[role=listbox]', '[role=combobox]', '[role=textbox]', '[role=grid]', '[role=application]',
79
+ ].join(', ');
80
+ // Ce qui fait son geste à Entrée : un lien, un bouton.
81
+ const elementsAEntree = 'a, button, summary, [role=button], [role=link], [role=tab], [role=menuitem]';
82
+ // La touche d'un aperçu ouvert, hors d'un champ, d'un éditeur ou d'une fenêtre : ↑ ↓ passent à la
83
+ // ligne voisine, Entrée agrandit, Échap ferme. Dans le corps de la chose, que l'app rend, ↑ ↓ et
84
+ // Entrée restent au corps ; Entrée sur un lien ou un bouton fait son geste.
85
+ function toucheDeLApercu(evenement) {
86
+ if (evenement.defaultPrevented || evenement.altKey || evenement.ctrlKey || evenement.metaKey || evenement.shiftKey || evenement.isComposing) {
87
+ return undefined;
88
+ }
89
+ const touches = { ArrowUp: 'precedente', ArrowDown: 'suivante', Enter: 'agrandir', Escape: 'fermer' };
90
+ const touche = touches[evenement.key];
91
+ if (!touche) {
92
+ return undefined;
93
+ }
94
+ const cible = evenement.target instanceof Element ? evenement.target : null;
95
+ if (cible?.closest(champsEtFenetres)) {
96
+ return undefined;
97
+ }
98
+ if (touche !== 'fermer' && cible?.closest(`[${attributDuCorps}]`)) {
99
+ return undefined;
100
+ }
101
+ if (touche === 'agrandir' && cible?.closest(elementsAEntree)) {
102
+ return undefined;
103
+ }
104
+ return touche;
105
+ }
@@ -24,11 +24,16 @@ export declare function cadreDe(session: Session, ici: string): CadreDeLaPage;
24
24
  export type EcranDeclare = {
25
25
  nom?: string;
26
26
  introuvable?: boolean;
27
+ chemin?: string;
27
28
  };
28
29
  export type Cadre = {
29
30
  fin: HTMLElement | null;
30
31
  gestes: HTMLElement | null;
32
+ menu: HTMLElement | null;
31
33
  declarer: (ecran: EcranDeclare) => void;
34
+ apercu?: {
35
+ quitter: () => void;
36
+ };
32
37
  };
33
38
  export declare const ContexteDuCadre: import("react").Context<Cadre | null>;
34
39
  export declare function useCadre(): Cadre | null;
@@ -39,8 +44,15 @@ export declare function DansLeFil({ children }: {
39
44
  export declare function DansLesGestes({ children }: {
40
45
  children: ReactNode;
41
46
  }): import("react").ReactPortal | null;
47
+ export declare function DansLeMenu({ children }: {
48
+ children: ReactNode;
49
+ }): import("react").ReactPortal | null;
42
50
  export declare const separateurDuFil: import("react").JSX.Element;
43
51
  export declare const classesDuTitre = "m-0 min-w-0 truncate text-[15px] leading-[1.4] font-semibold text-encre";
52
+ export declare function useTitreDuCadre(): {
53
+ Balise: 'h1' | 'h2';
54
+ tabIndex?: number;
55
+ };
44
56
  export declare function TitreDuFil({ children }: {
45
57
  children: ReactNode;
46
58
  }): import("react").JSX.Element;
@@ -10,11 +10,11 @@ export function appDuChemin(session, ici) {
10
10
  const nom = premier === 'documentation' ? second : premier;
11
11
  return session.apps.find((app) => app.nom === nom);
12
12
  }
13
- // Les onglets d'une app, dans leur ordre : ses écrans, « Réglages » quand la personne a le droit de
14
- // les voir, et « Documentation ».
13
+ // Les onglets d'une app, dans leur ordre : ses écrans, le premier sous le titre de l'app, « Réglages »
14
+ // quand la personne a le droit de les voir, et « Documentation ».
15
15
  export function ongletsDe(app) {
16
16
  return [
17
- ...app.ecrans.map((ecran) => ({ titre: ecran.titre, chemin: ecran.chemin })),
17
+ ...app.ecrans.map((ecran, rang) => ({ titre: rang === 0 ? app.titre : ecran.titre, chemin: ecran.chemin })),
18
18
  ...(app.reglages ? [{ titre: 'Réglages', chemin: `/${app.nom}/reglages` }] : []),
19
19
  { titre: 'Documentation', chemin: `/documentation/${app.nom}` },
20
20
  ];
@@ -32,7 +32,8 @@ function lienDeLOnglet(app, onglet) {
32
32
  }
33
33
  // Le cadre d'une page. Sur une page d'une app : le titre de l'app, puis l'onglet actif quand son
34
34
  // titre n'est pas celui de l'app, puis, sur un écran qui n'est pas l'onglet lui-même, le titre que
35
- // l'écran donne. Sur une page du core, le titre de l'écran seul.
35
+ // l'écran donne. Sur une page du core, le titre de l'écran seul. Sur un onglet, la coquille rend le
36
+ // `<h1>` elle-même, à l'onglet actif.
36
37
  export function cadreDe(session, ici) {
37
38
  const app = appDuChemin(session, ici);
38
39
  if (!app) {
@@ -73,17 +74,17 @@ export function useCadre() {
73
74
  // L'écran dit ce que la coquille ne sait pas de lui, tant qu'il est rendu.
74
75
  export function useDeclarerLEcran(ecran) {
75
76
  const cadre = useCadre();
76
- const { nom, introuvable } = ecran;
77
+ const { nom, introuvable, chemin } = ecran;
77
78
  useEffect(() => {
78
79
  if (!cadre) {
79
80
  return undefined;
80
81
  }
81
- cadre.declarer({ nom, introuvable });
82
+ cadre.declarer({ nom, introuvable, chemin });
82
83
  return () => cadre.declarer({});
83
- }, [cadre?.declarer, nom, introuvable]);
84
+ }, [cadre?.declarer, nom, introuvable, chemin]);
84
85
  }
85
- // Rendre à la fin du fil, et dans les gestes de l'écran : par un portail, dans l'emplacement que
86
- // donne la coquille.
86
+ // Rendre à la fin du fil, dans les gestes de l'écran, avant l'épingle, et dans le menu, après elle :
87
+ // par un portail, dans l'emplacement que donne la coquille.
87
88
  export function DansLeFil({ children }) {
88
89
  const cadre = useCadre();
89
90
  return cadre?.fin ? createPortal(children, cadre.fin) : null;
@@ -92,9 +93,19 @@ export function DansLesGestes({ children }) {
92
93
  const cadre = useCadre();
93
94
  return cadre?.gestes ? createPortal(children, cadre.gestes) : null;
94
95
  }
96
+ export function DansLeMenu({ children }) {
97
+ const cadre = useCadre();
98
+ return cadre?.menu ? createPortal(children, cadre.menu) : null;
99
+ }
95
100
  // Le séparateur du fil, et le dernier segment, le `<h1>` de l'écran.
96
101
  export const separateurDuFil = _jsx("span", { "aria-hidden": "true", className: "text-trait-champ max-[760px]:hidden", children: "/" });
97
102
  export const classesDuTitre = 'm-0 min-w-0 truncate text-[15px] leading-[1.4] font-semibold text-encre';
103
+ // La balise du titre : le `<h1>` de l'écran ; dans un aperçu, sous le `<h1>` de la liste, un `<h2>`
104
+ // que le panneau focalise à son ouverture.
105
+ export function useTitreDuCadre() {
106
+ return useCadre()?.apercu ? { Balise: 'h2', tabIndex: -1 } : { Balise: 'h1' };
107
+ }
98
108
  export function TitreDuFil({ children }) {
99
- return _jsx("h1", { className: classesDuTitre, children: children });
109
+ const { Balise, tabIndex } = useTitreDuCadre();
110
+ return _jsx(Balise, { tabIndex: tabIndex, className: classesDuTitre, children: children });
100
111
  }