@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
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
|
+
}
|
package/src/espace/choses.d.ts
CHANGED
|
@@ -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>;
|
package/src/espace/choses.js
CHANGED
|
@@ -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) {
|
package/src/espace/coquille.js
CHANGED
|
@@ -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: [
|
|
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,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
|
|
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 {
|
|
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 :
|
|
21
|
-
//
|
|
22
|
-
//
|
|
23
|
-
//
|
|
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
|
-
|
|
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:
|
|
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(
|
|
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;
|