@nodefony/frontend 10.0.0-beta.1 → 10.0.0-beta.3
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/README.md +56 -68
- package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorate.js +1 -1
- package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorateMetadata.js +1 -1
- package/dist/index.js +2 -2
- package/dist/nodefony/config/config.js +3 -8
- package/dist/nodefony/service/FrontendService.js +73 -295
- package/dist/nodefony/service/ViteConfigGenerator.js +11 -30
- package/dist/nodefony/service/ViteProcessSupervisor.js +17 -12
- package/dist/nodefony/service/bootSummary.js +44 -0
- package/dist/nodefony/src/isolationGroups.js +27 -32
- package/dist/nodefony/src/template/TemplateHelper.js +52 -19
- package/dist/types/nodefony/config/config.d.ts +0 -8
- package/dist/types/nodefony/interfaces/IFrontBuilder.d.ts +0 -9
- package/dist/types/nodefony/interfaces/IFrontendService.d.ts +6 -10
- package/dist/types/nodefony/interfaces/IViteSupervisor.d.ts +11 -5
- package/dist/types/nodefony/service/FrontendService.d.ts +24 -118
- package/dist/types/nodefony/service/ViteConfigGenerator.d.ts +13 -21
- package/dist/types/nodefony/service/ViteProcessSupervisor.d.ts +13 -16
- package/dist/types/nodefony/service/bootSummary.d.ts +23 -0
- package/dist/types/nodefony/src/isolationGroups.d.ts +24 -23
- package/dist/types/nodefony/src/template/TemplateHelper.d.ts +23 -7
- package/docs/index.md +173 -145
- package/package.json +12 -13
- package/dist/nodefony/src/remoteDev.js +0 -216
- package/dist/types/nodefony/src/remoteDev.d.ts +0 -152
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
//#region nodefony/service/bootSummary.ts
|
|
2
|
+
/**
|
|
3
|
+
* Résume les instances Vite pour le bilan de démarrage — fonction PURE (les
|
|
4
|
+
* statuts sont lus par l'appelant), éprouvable sans lancer Vite.
|
|
5
|
+
*
|
|
6
|
+
* @param statuses - l'état de chaque superviseur Vite, après démarrage.
|
|
7
|
+
* @returns lignes de détail, nombre d'instances prêtes, point d'attention.
|
|
8
|
+
*/
|
|
9
|
+
function summarizeFrontendBoot(statuses) {
|
|
10
|
+
const lines = [];
|
|
11
|
+
const failed = [];
|
|
12
|
+
let ready = 0;
|
|
13
|
+
for (const st of statuses) {
|
|
14
|
+
const names = st.entries.map((e) => e.entryName).join(", ");
|
|
15
|
+
if (st.state === "ready") {
|
|
16
|
+
ready++;
|
|
17
|
+
lines.push(`${names} · Vite interne${st.port === null ? "" : ` :${st.port}`}`);
|
|
18
|
+
} else {
|
|
19
|
+
failed.push(names);
|
|
20
|
+
const state = st.state === "errored" || st.state === "crashed" ? "en échec" : `pas prêt (${st.state})`;
|
|
21
|
+
lines.push(`${names} · Vite ${state}${st.lastError ? ` — ${st.lastError}` : ""}`);
|
|
22
|
+
}
|
|
23
|
+
}
|
|
24
|
+
let notice = null;
|
|
25
|
+
if (statuses.length > 0 && ready === 0) notice = {
|
|
26
|
+
code: "FRONTEND_BUILD_FAILED",
|
|
27
|
+
level: "error",
|
|
28
|
+
message: "Aucune instance Vite n'est prête — aucun bundle n'est servi",
|
|
29
|
+
fix: "nodefony development --debug (journal Vite complet)"
|
|
30
|
+
};
|
|
31
|
+
else if (failed.length > 0) notice = {
|
|
32
|
+
code: "FRONTEND_PARTIAL",
|
|
33
|
+
level: "warning",
|
|
34
|
+
message: `Vite pas prêt pour ${failed.join(" · ")} — les autres bundles sont servis`,
|
|
35
|
+
fix: "nodefony development --debug (journal Vite complet)"
|
|
36
|
+
};
|
|
37
|
+
return {
|
|
38
|
+
ready,
|
|
39
|
+
lines,
|
|
40
|
+
notice
|
|
41
|
+
};
|
|
42
|
+
}
|
|
43
|
+
//#endregion
|
|
44
|
+
export { summarizeFrontendBoot };
|
|
@@ -45,6 +45,32 @@ function isolationGroup(type) {
|
|
|
45
45
|
}
|
|
46
46
|
}
|
|
47
47
|
/**
|
|
48
|
+
* Espace d'URL réservé aux serveurs Vite de développement, sur l'origine de
|
|
49
|
+
* Nodefony. Chaque famille y a son sous-préfixe (cf {@link devBasePath}).
|
|
50
|
+
*/
|
|
51
|
+
const DEV_BASE_ROOT = "/_vite/";
|
|
52
|
+
/**
|
|
53
|
+
* Chemin de base Vite d'une famille en développement (`/_vite/<famille>/`).
|
|
54
|
+
*
|
|
55
|
+
* Vite fabrique ses URLs d'assets RELATIVES AU DOCUMENT : une image importée
|
|
56
|
+
* devient `/<base>/src/logo.png`, que le navigateur résout contre l'origine de
|
|
57
|
+
* la page — servie par Nodefony, pas par Vite. Un préfixe réservé rend ces
|
|
58
|
+
* URLs reconnaissables : Nodefony les relaie (307) vers le serveur Vite, sans
|
|
59
|
+
* collision possible avec les routes de l'application. Un préfixe PAR famille,
|
|
60
|
+
* parce que chaque famille a son instance Vite, sur son port : le relais doit
|
|
61
|
+
* savoir vers laquelle renvoyer.
|
|
62
|
+
*
|
|
63
|
+
* `base` est l'option que Vite honore partout — dev classique, dev bundlé,
|
|
64
|
+
* socket HMR, `@vitejs/plugin-vue`, publicDir —, contrairement à
|
|
65
|
+
* `server.origin`, ignoré en mode bundlé.
|
|
66
|
+
*
|
|
67
|
+
* @param family - clé de famille ({@link isolationGroup})
|
|
68
|
+
* @returns le chemin, `/` en tête et en fin
|
|
69
|
+
*/
|
|
70
|
+
function devBasePath(family) {
|
|
71
|
+
return `${DEV_BASE_ROOT}${family}/`;
|
|
72
|
+
}
|
|
73
|
+
/**
|
|
48
74
|
* Famille servie sur le port de base (`devPort`). Les autres familles prennent
|
|
49
75
|
* les blocs de ports suivants. Garder `default` ici garantit que l'instance
|
|
50
76
|
* principale (React/Svelte/vanilla/Studio) reste sur le port habituel (5173).
|
|
@@ -81,36 +107,5 @@ function familyPortPlan(devPort, families, portRetryAttempts) {
|
|
|
81
107
|
});
|
|
82
108
|
return plan;
|
|
83
109
|
}
|
|
84
|
-
/**
|
|
85
|
-
* Bloc de ports de chaque famille : tous les ports que SON instance Vite peut
|
|
86
|
-
* prendre, port-retry compris.
|
|
87
|
-
*
|
|
88
|
-
* Le plan seul ne dit que le port ESPÉRÉ ; sur `EADDRINUSE` le superviseur
|
|
89
|
-
* glisse dans son bloc. Un CSP construit sur le seul port espéré laisse la page
|
|
90
|
-
* sans rechargement à chaud dès que le port de base est pris — et il l'est dès
|
|
91
|
-
* qu'un second projet tourne sur la machine.
|
|
92
|
-
*
|
|
93
|
-
* Rendu par famille, et non à plat : le consommateur remplace le bloc d'une
|
|
94
|
-
* famille par son port RÉEL dès qu'il est connu. Déclarer les douze ports d'un
|
|
95
|
-
* poste à trois familles coûte un en-tête CSP de ~8 Ko sur chaque réponse
|
|
96
|
-
* (mesuré) — la plage est le prix d'une incertitude, elle ne doit pas survivre
|
|
97
|
-
* à sa levée.
|
|
98
|
-
*
|
|
99
|
-
* Dérivé du plan plutôt que recalculé depuis `devPort` : la règle des blocs
|
|
100
|
-
* disjoints n'est écrite qu'à un endroit, `familyPortPlan`.
|
|
101
|
-
*
|
|
102
|
-
* @param plan - `famille → port de base`, tel que rendu par `familyPortPlan`.
|
|
103
|
-
* @param portRetryAttempts - tentatives de port-retry par instance (bloc = +1).
|
|
104
|
-
* @returns `famille → ports du bloc`, croissants.
|
|
105
|
-
*/
|
|
106
|
-
function familyPortBlocks(plan, portRetryAttempts) {
|
|
107
|
-
const blocks = /* @__PURE__ */ new Map();
|
|
108
|
-
for (const [family, base] of plan) {
|
|
109
|
-
const ports = [];
|
|
110
|
-
for (let i = 0; i <= portRetryAttempts; i++) ports.push(base + i);
|
|
111
|
-
blocks.set(family, ports);
|
|
112
|
-
}
|
|
113
|
-
return blocks;
|
|
114
|
-
}
|
|
115
110
|
//#endregion
|
|
116
|
-
export { PRIMARY_FAMILY,
|
|
111
|
+
export { DEV_BASE_ROOT, PRIMARY_FAMILY, devBasePath, familyPortPlan, isolationGroup, orderFamilies };
|
|
@@ -1,10 +1,19 @@
|
|
|
1
|
-
import { isLoopbackHostname, originWithHostname } from "../remoteDev.js";
|
|
2
1
|
import { createRequire } from "node:module";
|
|
3
|
-
import { PLATFORM_EVENTS, escapeRegExp } from "nodefony";
|
|
2
|
+
import { Nodefony, PLATFORM_EVENTS, escapeRegExp } from "nodefony";
|
|
4
3
|
import path from "node:path";
|
|
5
4
|
import fs from "node:fs";
|
|
6
5
|
//#region nodefony/src/template/TemplateHelper.ts
|
|
7
6
|
/**
|
|
7
|
+
* Chemin de base de l'instance, sans `/` final : `/_vite/default` pour
|
|
8
|
+
* `/_vite/default/`, vide pour `/` (doubles de test sans `base`). C'est TOUT
|
|
9
|
+
* le préfixe des URLs émises vers Vite : elles sont relatives à la page, que
|
|
10
|
+
* Nodefony relaie (proxy inverse, #528).
|
|
11
|
+
*/
|
|
12
|
+
function basePathOf(status) {
|
|
13
|
+
const base = status.base ?? "/";
|
|
14
|
+
return base.endsWith("/") ? base.slice(0, -1) : base;
|
|
15
|
+
}
|
|
16
|
+
/**
|
|
8
17
|
* Chemin résolu (1×, caché) du build navigateur de la debug bar Nodefony
|
|
9
18
|
* (`nodefony/debugbar`). `undefined` = pas encore tenté, `null` = irrésolu.
|
|
10
19
|
*/
|
|
@@ -46,18 +55,40 @@ var TemplateHelper = class {
|
|
|
46
55
|
this.assetBaseUrl = assetBaseUrl;
|
|
47
56
|
}
|
|
48
57
|
/**
|
|
58
|
+
* Origine LOCALE du serveur Vite — la cible du proxy inverse que Nodefony
|
|
59
|
+
* monte sur `/_vite/<famille>/` (#528). Jamais annoncée au navigateur : la
|
|
60
|
+
* page ne connaît que sa propre origine, Vite reste sur la boucle locale.
|
|
61
|
+
*
|
|
62
|
+
* 🔴 Seul un Vite qui SERT (`ready`, `compiling`) est une cible. Un port
|
|
63
|
+
* retenu par une instance tombée ou en redémarrage peut avoir été repris
|
|
64
|
+
* par le Vite d'une AUTRE application de la machine (même préfixe
|
|
65
|
+
* `/_vite/<famille>/`) : relayer vers lui servirait les sources de l'autre
|
|
66
|
+
* application à cette page. Le superviseur quitte `ready` dès l'`exit` de
|
|
67
|
+
* son processus — avant qu'un autre ne puisse reprendre le port.
|
|
68
|
+
*
|
|
69
|
+
* @returns l'origine (`http://127.0.0.1:5173`), ou `undefined` sans
|
|
70
|
+
* superviseur, tant que Vite n'a pas résolu son port, ou quand il ne sert
|
|
71
|
+
* pas (amont pas prêt : le relais répond `503`, avant tout `101` pour la
|
|
72
|
+
* socket — le client Vite ne recharge la page qu'une fois Vite revenu)
|
|
73
|
+
*/
|
|
74
|
+
devTarget() {
|
|
75
|
+
if (!this.supervisor) return void 0;
|
|
76
|
+
const status = this.supervisor.status();
|
|
77
|
+
if (status.port === null) return void 0;
|
|
78
|
+
if (status.state !== "ready" && status.state !== "compiling") return;
|
|
79
|
+
return status.origin ?? `${status.https ? "https" : "http"}://${status.host}:${status.port}`;
|
|
80
|
+
}
|
|
81
|
+
/**
|
|
49
82
|
* Tags à injecter dans `<head>` (ou avant `</body>`) pour une entrée donnée.
|
|
83
|
+
* En développement, toutes les URLs vers Vite sont relatives à la page
|
|
84
|
+
* (`/_vite/<famille>/…`) : Nodefony les relaie, la page n'a qu'une origine.
|
|
85
|
+
*
|
|
50
86
|
* @param entryName nom logique de l'entrée (matche `entryName` dans IResolvedFrontendEntry)
|
|
51
87
|
* @param nonce nonce CSP de la requête (`Context.cspNonce`) — posé sur les `<script>`
|
|
52
88
|
* pour satisfaire `script-src 'nonce-…'` (preamble inline dev + entrée prod).
|
|
53
|
-
* @param requestHost nom d'hôte par lequel le client a demandé la PAGE
|
|
54
|
-
* (`Context.domain`, sans port). Dev : l'origine des assets est réécrite
|
|
55
|
-
* sur ce nom (scheme et port restent ceux de Vite) → poste et conteneur
|
|
56
|
-
* servis par la même instance. Prod : **ignoré** — les URLs du manifest
|
|
57
|
-
* sont relatives au document, elles suivent déjà l'hôte de la page.
|
|
58
89
|
*/
|
|
59
|
-
renderTags(entryName, nonce
|
|
60
|
-
if (this.mode === "development") return this.renderDevTags(entryName, nonce
|
|
90
|
+
renderTags(entryName, nonce) {
|
|
91
|
+
if (this.mode === "development") return this.renderDevTags(entryName, nonce);
|
|
61
92
|
return this.renderProdTags(entryName, nonce);
|
|
62
93
|
}
|
|
63
94
|
/**
|
|
@@ -69,8 +100,8 @@ var TemplateHelper = class {
|
|
|
69
100
|
*
|
|
70
101
|
* @param entryName nom logique de l'entrée
|
|
71
102
|
*/
|
|
72
|
-
renderDocument(entryName, nonce
|
|
73
|
-
const tags = this.renderTags(entryName, nonce
|
|
103
|
+
renderDocument(entryName, nonce) {
|
|
104
|
+
const tags = this.renderTags(entryName, nonce);
|
|
74
105
|
const entry = this.entries.find((e) => e.entryName === entryName) ?? this.supervisor?.status().entries.find((e) => e.entryName === entryName);
|
|
75
106
|
const html = entry ? this.loadIndexHtml(entry.root) : null;
|
|
76
107
|
if (!entry || !html) return `<!DOCTYPE html>
|
|
@@ -113,14 +144,13 @@ ${tags}
|
|
|
113
144
|
if (this.mode === "production") this.indexCache.set(root, html);
|
|
114
145
|
return html;
|
|
115
146
|
}
|
|
116
|
-
renderDevTags(entryName, nonce
|
|
147
|
+
renderDevTags(entryName, nonce) {
|
|
117
148
|
if (!this.supervisor) return `<!-- @nodefony/frontend: no vite supervisor (dev) -->`;
|
|
118
149
|
const status = this.supervisor.status();
|
|
119
150
|
if (status.state !== "ready") return `<!-- @nodefony/frontend: vite supervisor state=${status.state} -->`;
|
|
120
151
|
const entry = status.entries.find((e) => e.entryName === entryName);
|
|
121
152
|
if (!entry) return `<!-- @nodefony/frontend: unknown entry "${entryName}" -->`;
|
|
122
|
-
const
|
|
123
|
-
const baseUrl = !requestHost ? resolvedOrigin : isLoopbackHostname(requestHost) ? `${status.https ? "https" : "http"}://${requestHost}:${status.port}` : originWithHostname(resolvedOrigin, requestHost) ?? resolvedOrigin;
|
|
153
|
+
const baseUrl = basePathOf(status);
|
|
124
154
|
const absEntryPath = path.resolve(entry.root, entry.entryFile).replace(/\\/g, "/");
|
|
125
155
|
const entryUrl = `${baseUrl}${absEntryPath.startsWith("/") ? `/@fs${absEntryPath}` : `/@fs/${absEntryPath}`}`;
|
|
126
156
|
const tags = [];
|
|
@@ -180,11 +210,14 @@ try {
|
|
|
180
210
|
if (!debugbarFile) return `<!-- @nodefony/frontend: debugbar unresolved -->`;
|
|
181
211
|
const norm = debugbarFile.replace(/\\/g, "/");
|
|
182
212
|
const fsUrl = `${baseUrl}${norm.startsWith("/") ? `/@fs${norm}` : `/@fs/${norm}`}`;
|
|
183
|
-
const opts = JSON.stringify({
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
213
|
+
const opts = JSON.stringify({
|
|
214
|
+
frontend: {
|
|
215
|
+
framework,
|
|
216
|
+
name: entryName,
|
|
217
|
+
viteOrigin: baseUrl
|
|
218
|
+
},
|
|
219
|
+
env: Nodefony.getKernel()?.environment ?? ""
|
|
220
|
+
});
|
|
188
221
|
return `<script type="module"${nonceAttr}>
|
|
189
222
|
import { mountDebugBar } from ${JSON.stringify(fsUrl)};
|
|
190
223
|
mountDebugBar(${opts});
|
|
@@ -2,20 +2,12 @@ import { z } from "zod";
|
|
|
2
2
|
export declare const frontendConfigSchema: z.ZodObject<{
|
|
3
3
|
devHost: z.ZodDefault<z.ZodString>;
|
|
4
4
|
devPort: z.ZodDefault<z.ZodNumber>;
|
|
5
|
-
publicOrigin: z.ZodDefault<z.ZodString>;
|
|
6
5
|
autoStartInDevelopment: z.ZodDefault<z.ZodBoolean>;
|
|
7
6
|
defaultOutDir: z.ZodDefault<z.ZodString>;
|
|
8
7
|
defaultRoot: z.ZodDefault<z.ZodString>;
|
|
9
8
|
assetBaseUrl: z.ZodDefault<z.ZodString>;
|
|
10
9
|
startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
|
|
11
10
|
pipeViteLogs: z.ZodDefault<z.ZodBoolean>;
|
|
12
|
-
backendHost: z.ZodDefault<z.ZodString>;
|
|
13
|
-
backendPort: z.ZodDefault<z.ZodNumber>;
|
|
14
|
-
backendProtocol: z.ZodDefault<z.ZodEnum<{
|
|
15
|
-
http: "http";
|
|
16
|
-
https: "https";
|
|
17
|
-
}>>;
|
|
18
|
-
https: z.ZodDefault<z.ZodBoolean>;
|
|
19
11
|
viteEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
20
12
|
resilience: z.ZodDefault<z.ZodObject<{
|
|
21
13
|
autoRestart: z.ZodDefault<z.ZodBoolean>;
|
|
@@ -24,13 +24,6 @@ export interface IFrontendModuleDeclaration {
|
|
|
24
24
|
* au build ET de mount prefix au serveur statique → les deux restent alignés.
|
|
25
25
|
*/
|
|
26
26
|
readonly publicPath?: string;
|
|
27
|
-
/**
|
|
28
|
-
* Préfixes de paths à proxifier depuis Vite vers Nodefony (dev only).
|
|
29
|
-
* Sans ça, un `fetch("/poc/api/data")` depuis l'app React servie par Vite
|
|
30
|
-
* tape Vite (qui retourne son index.html SPA-fallback) au lieu du backend.
|
|
31
|
-
* Exemple : `["/poc/api", "/nodefony"]`.
|
|
32
|
-
*/
|
|
33
|
-
readonly apiProxyPaths?: ReadonlyArray<string>;
|
|
34
27
|
}
|
|
35
28
|
/**
|
|
36
29
|
* Description résolue d'une entrée front, prête à être passée au superviseur Vite.
|
|
@@ -47,8 +40,6 @@ export interface IResolvedFrontendEntry {
|
|
|
47
40
|
* — `base` Vite en prod + mount prefix du serveur statique.
|
|
48
41
|
*/
|
|
49
42
|
readonly publicPath: string;
|
|
50
|
-
/** Préfixes à proxifier vers Nodefony (résolus depuis la déclaration). */
|
|
51
|
-
readonly apiProxyPaths: ReadonlyArray<string>;
|
|
52
43
|
}
|
|
53
44
|
/**
|
|
54
45
|
* Builder responsable de construire la config Vite finale à partir
|
|
@@ -51,23 +51,19 @@ export interface IFrontendService {
|
|
|
51
51
|
/**
|
|
52
52
|
* Helper template — retourne les balises `<script>` à injecter dans une page.
|
|
53
53
|
*
|
|
54
|
+
* En développement, les URLs vers Vite sont RELATIVES à la page
|
|
55
|
+
* (`/_vite/<famille>/…`, relayées par Nodefony) : elles suivent d'elles-mêmes
|
|
56
|
+
* l'hôte par lequel le client est arrivé.
|
|
57
|
+
*
|
|
54
58
|
* @param nonce nonce CSP de la requête (`Context.cspNonce`).
|
|
55
|
-
* @param requestHost nom d'hôte par lequel le client a demandé la page
|
|
56
|
-
* (`Context.domain`, sans port). En développement, l'origine des assets
|
|
57
|
-
* Vite est dérivée de ce nom — le scheme et le port restent ceux de Vite —
|
|
58
|
-
* de sorte qu'un poste et un conteneur soient servis en même temps sans
|
|
59
|
-
* configuration. Ignoré si `frontend.publicOrigin` est configurée, si
|
|
60
|
-
* l'hôte ne franchit pas `trustedHosts`, et en production.
|
|
61
59
|
*/
|
|
62
|
-
renderTags(entryName: string, nonce?: string
|
|
60
|
+
renderTags(entryName: string, nonce?: string): string;
|
|
63
61
|
/**
|
|
64
62
|
* Document HTML complet : `index.html` du module + tags injectés. Pour les
|
|
65
63
|
* controllers qui veulent déléguer toute la coquille (le dev contrôle le
|
|
66
64
|
* `<head>` via son `index.html`).
|
|
67
|
-
*
|
|
68
|
-
* @param requestHost cf {@link IFrontendService.renderTags}.
|
|
69
65
|
*/
|
|
70
|
-
renderDocument(entryName: string, nonce?: string
|
|
66
|
+
renderDocument(entryName: string, nonce?: string): string;
|
|
71
67
|
/**
|
|
72
68
|
* Résout l'URL publique d'un asset : préfixe `p` par `assetBaseUrl` (CDN) si
|
|
73
69
|
* configuré, sinon chemin relatif inchangé. URLs absolues renvoyées telles
|
|
@@ -12,13 +12,19 @@ export interface IViteSupervisorStatus {
|
|
|
12
12
|
readonly host: string;
|
|
13
13
|
readonly port: number | null;
|
|
14
14
|
/**
|
|
15
|
-
* Origine
|
|
16
|
-
*
|
|
17
|
-
*
|
|
18
|
-
*
|
|
19
|
-
*
|
|
15
|
+
* Origine LOCALE du dev server (`http://127.0.0.1:<port réel>`) : la cible
|
|
16
|
+
* du proxy inverse de Nodefony. Le navigateur ne la voit jamais — il passe
|
|
17
|
+
* par `/_vite/<famille>/` sur l'origine de la page. Source unique de cette
|
|
18
|
+
* cible (TemplateHelper, boot line, admin API). `null` tant qu'aucun spawn
|
|
19
|
+
* n'a résolu de port.
|
|
20
20
|
*/
|
|
21
21
|
readonly origin: string | null;
|
|
22
|
+
/**
|
|
23
|
+
* Chemin de base Vite de cette instance (`/_vite/<famille>/`, `/` en tête et
|
|
24
|
+
* en fin). Toute URL émise vers Vite le porte : c'est lui que Nodefony relaie.
|
|
25
|
+
* Absent quand le superviseur n'en a pas reçu (doubles de test) → `/`.
|
|
26
|
+
*/
|
|
27
|
+
readonly base?: string;
|
|
22
28
|
readonly pid: number | null;
|
|
23
29
|
readonly lastError: string | null;
|
|
24
30
|
readonly entries: ReadonlyArray<IResolvedFrontendEntry>;
|
|
@@ -28,33 +28,6 @@ declare class FrontendService extends Service implements IFrontendService {
|
|
|
28
28
|
private readonly entryFamily;
|
|
29
29
|
/** Helper prod unique (lit les manifests) — `null` tant qu'on n'est pas en prod. */
|
|
30
30
|
private prodHelper;
|
|
31
|
-
/**
|
|
32
|
-
* QUI a épinglé l'origine publique — la question n'est pas « est-elle
|
|
33
|
-
* épinglée » mais « par quoi », car les deux sources n'ont pas la même
|
|
34
|
-
* autorité :
|
|
35
|
-
*
|
|
36
|
-
* - `"config"` — `frontend.publicOrigin` : une décision ÉCRITE par l'auteur.
|
|
37
|
-
* Elle gagne sur tout, y compris sur le `Host` reçu : c'est le sens même
|
|
38
|
-
* d'un réglage explicite, et le seul moyen de servir derrière un frontal
|
|
39
|
-
* qui réécrit l'origine.
|
|
40
|
-
* - `"platform"` — Codespaces/Gitpod déduits de l'environnement : une
|
|
41
|
-
* DÉDUCTION, faite une fois au démarrage, sur une machine qui reçoit
|
|
42
|
-
* simultanément des clients arrivés par des chemins différents. Elle ne
|
|
43
|
-
* peut donc pas prévaloir sur un fait constaté à la requête — un client
|
|
44
|
-
* venu de la boucle locale se sert en local (cf `derivableHost`).
|
|
45
|
-
* - `null` — rien d'épinglé : chaque page annonce l'origine par laquelle son
|
|
46
|
-
* client est arrivé.
|
|
47
|
-
*/
|
|
48
|
-
private originPinnedBy;
|
|
49
|
-
/**
|
|
50
|
-
* Ports que l'instance Vite de chaque famille PEUT prendre pour ce démarrage
|
|
51
|
-
* (bloc de la famille, port-retry compris) — `null` tant que `startDev` n'a
|
|
52
|
-
* pas établi le plan, et remis à `null` par `stopDev`.
|
|
53
|
-
*
|
|
54
|
-
* Alloué une fois par démarrage de développement, jamais en production
|
|
55
|
-
* (`startDev` n'y tourne pas) : aucun coût par requête.
|
|
56
|
-
*/
|
|
57
|
-
private plannedPortBlocks;
|
|
58
31
|
constructor(module: Module);
|
|
59
32
|
/** Base CDN normalisée (sans slash final). `""` = origine Nodefony. */
|
|
60
33
|
private get assetBase();
|
|
@@ -90,53 +63,6 @@ declare class FrontendService extends Service implements IFrontendService {
|
|
|
90
63
|
* famille n'a pu démarrer.
|
|
91
64
|
*/
|
|
92
65
|
startDev(): Promise<void>;
|
|
93
|
-
/**
|
|
94
|
-
* Port backend que Vite doit proxifier — le port RÉELLEMENT écouté, pas celui
|
|
95
|
-
* qu'on espérait.
|
|
96
|
-
*
|
|
97
|
-
* `config.backendPort` (5151) n'est qu'une intention : avec
|
|
98
|
-
* `servers.portPolicy: "auto"`, un port occupé fait glisser l'écoute du backend
|
|
99
|
-
* (5151 → 5153). Un proxy figé sur 5151 enverrait alors les appels API du front
|
|
100
|
-
* vers le serveur d'une AUTRE app — au mieux des 404, au pire les données du
|
|
101
|
-
* voisin. On lit donc le port sur le serveur lui-même.
|
|
102
|
-
*
|
|
103
|
-
* Résolution par NOM (`server-http`), jamais par import : `@nodefony/frontend`
|
|
104
|
-
* ne dépend pas de `@nodefony/http` (cycle via la config d'app).
|
|
105
|
-
*/
|
|
106
|
-
private resolveBackendPort;
|
|
107
|
-
/**
|
|
108
|
-
* Résout les certificats HTTPS partagés (service `certificates` de
|
|
109
|
-
* @nodefony/http) si `https: true`. Pas de duplication — mêmes PEM que
|
|
110
|
-
* `server-https` (5152). Retombe sur HTTP avec un warning si indisponible.
|
|
111
|
-
*/
|
|
112
|
-
private resolveHttps;
|
|
113
|
-
/**
|
|
114
|
-
* Template d'origine publique Vite (P14.17), AVEC sa provenance. Priorité :
|
|
115
|
-
* `frontend.publicOrigin` (config, validée — invalide = ERROR + ignorée,
|
|
116
|
-
* jamais un boot cassé) puis détection de plateforme (Codespaces/Gitpod —
|
|
117
|
-
* variables documentées de la plateforme, qu'on lit sans les posséder).
|
|
118
|
-
* `null` = dérivation locale.
|
|
119
|
-
*
|
|
120
|
-
* La provenance est rendue avec le template parce qu'elle CHANGE la suite :
|
|
121
|
-
* une config écrite est un ordre, une plateforme déduite est une supposition
|
|
122
|
-
* qui cède devant le `Host` reçu quand celui-ci désigne la boucle locale
|
|
123
|
-
* (cf `originPinnedBy`). Les confondre servait l'origine publique à un client
|
|
124
|
-
* venu d'un tunnel local, qui n'a pas la session de la plateforme.
|
|
125
|
-
*
|
|
126
|
-
* Chaque adaptation est JOURNALISÉE : on doit pouvoir lire dans le boot
|
|
127
|
-
* pourquoi les `<script>` pointent où ils pointent.
|
|
128
|
-
*/
|
|
129
|
-
private resolvePublicOrigin;
|
|
130
|
-
/**
|
|
131
|
-
* `server.allowedHosts` pour Vite. Vite accepte d'office IP et `localhost` ;
|
|
132
|
-
* cette liste ne porte que les NOMS. Source des noms légitimes = la MÊME que
|
|
133
|
-
* la barrière Host de Nodefony (`kernel.domain` + `trustedHosts` http) — une
|
|
134
|
-
* seule liste à maintenir : autoriser un hôte dans `trustedHosts` ouvre à la
|
|
135
|
-
* fois la barrière 421 ET Vite. S'y ajoute l'hôte du template d'origine
|
|
136
|
-
* publique. `trustedHosts: true` (barrière déléguée au reverse-proxy) →
|
|
137
|
-
* `true` (même délégation). Un pattern non exprimable chez Vite est ANNONCÉ.
|
|
138
|
-
*/
|
|
139
|
-
private viteAllowedHosts;
|
|
140
66
|
/** Regroupe les entries par famille d'isolation + remplit l'index inverse. */
|
|
141
67
|
private groupEntriesByFamily;
|
|
142
68
|
/**
|
|
@@ -145,6 +71,28 @@ declare class FrontendService extends Service implements IFrontendService {
|
|
|
145
71
|
* observable même si le démarrage échoue → rendu propre, pas d'exception).
|
|
146
72
|
*/
|
|
147
73
|
private startFamily;
|
|
74
|
+
/**
|
|
75
|
+
* Monte `/_vite/<famille>/` sur le proxy inverse de `@nodefony/http` (#528).
|
|
76
|
+
*
|
|
77
|
+
* Tout ce que la page demande à Vite — modules, images importées, `url()`
|
|
78
|
+
* CSS, socket du rechargement à chaud — porte ce préfixe (`base` Vite) et
|
|
79
|
+
* reste donc sur l'ORIGINE DE LA PAGE : un certificat, aucun contenu mixte,
|
|
80
|
+
* et les API réservées aux contextes sécurisés (caméra, Service Workers,
|
|
81
|
+
* WebAuthn) disponibles depuis un téléphone, une IP de réseau local ou un
|
|
82
|
+
* navigateur en conteneur. Vite, lui, reste sur la boucle locale.
|
|
83
|
+
*
|
|
84
|
+
* GET/HEAD seulement (Vite ne sert que des lectures) ; `cookie` et
|
|
85
|
+
* `authorization` ne lui parviennent pas — un serveur de sources n'a pas à
|
|
86
|
+
* voir la session. Posé avant `start()` : tant que Vite n'est pas prêt, la
|
|
87
|
+
* cible est inconnue et le relais répond `503` — à la socket de sonde du
|
|
88
|
+
* client Vite comprise, AVANT tout `101` : la page ne recharge qu'une fois
|
|
89
|
+
* Vite revenu, jamais sur une page blanche (#577). No-op sans proxy
|
|
90
|
+
* (application sans serveur HTTP).
|
|
91
|
+
*
|
|
92
|
+
* @param devBase - chemin de base de la famille (`devBasePath`)
|
|
93
|
+
* @param helper - helper de la famille, qui connaît son superviseur
|
|
94
|
+
*/
|
|
95
|
+
private mountDevProxy;
|
|
148
96
|
/**
|
|
149
97
|
* Câblage prod (idempotent) : monte chaque `outDir` sur son `publicPath`
|
|
150
98
|
* auprès du serveur statique `server-static` (résolu par nom — pas d'import
|
|
@@ -201,49 +149,7 @@ declare class FrontendService extends Service implements IFrontendService {
|
|
|
201
149
|
* Le controller renvoie : `this.render(svc.renderDocument("x", this.context.cspNonce))`.
|
|
202
150
|
* @param nonce nonce CSP de la requête (`Context.cspNonce`) — propagé aux `<script>`.
|
|
203
151
|
*/
|
|
204
|
-
renderDocument(entryName: string, nonce?: string
|
|
205
|
-
renderTags(entryName: string, nonce?: string
|
|
206
|
-
/**
|
|
207
|
-
* Le `Host` de la requête peut-il servir à dériver l'origine des assets ?
|
|
208
|
-
*
|
|
209
|
-
* Trois conditions, dans cet ordre — chacune protège un cas RÉEL :
|
|
210
|
-
* 1. **origine non épinglée** : un `frontend.publicOrigin` explicite (ou une
|
|
211
|
-
* plateforme de dev déporté détectée) est une décision de l'auteur, elle
|
|
212
|
-
* gagne toujours sur une déduction ;
|
|
213
|
-
* 2. **barrière `trustedHosts` franchie** : le `Host` est une donnée
|
|
214
|
-
* CLIENTE. Sans ce filtre, un `Host` forgé ferait émettre des
|
|
215
|
-
* `<script src="https://attaquant:5173/…">` dans une page de dev ;
|
|
216
|
-
* 3. **barrière non déléguée** (`trustedHosts !== true`) : le bypass total
|
|
217
|
-
* ne dit plus rien de la légitimité d'un nom, et surtout le CSP émis par
|
|
218
|
-
* le firewall (`#viteCspFragment`) ne couvre alors QUE loopback +
|
|
219
|
-
* domaine canonique — dériver ailleurs produirait une page dont les
|
|
220
|
-
* scripts sont bloqués. Les deux listes doivent rester la même liste.
|
|
221
|
-
*
|
|
222
|
-
* @returns le nom d'hôte à employer, ou `undefined` pour garder l'origine
|
|
223
|
-
* résolue au démarrage (comportement d'avant la dérivation).
|
|
224
|
-
*/
|
|
225
|
-
private derivableHost;
|
|
226
|
-
/**
|
|
227
|
-
* Ports Vite à déclarer au CSP, famille par famille : le BLOC entier tant que
|
|
228
|
-
* l'instance ne sert pas, son port RÉEL dès qu'elle sert.
|
|
229
|
-
*
|
|
230
|
-
* Pourquoi le bloc avant : le CSP part AVEC la page et ne se renégocie jamais.
|
|
231
|
-
* Une page servie avant que Vite ait résolu son port doit déjà porter le port
|
|
232
|
-
* qu'il prendra, sinon son socket de rechargement à chaud est refusé pour
|
|
233
|
-
* toute la durée de la page.
|
|
234
|
-
*
|
|
235
|
-
* Pourquoi le port seul après : la plage est le prix d'une incertitude, elle
|
|
236
|
-
* ne doit pas lui survivre. Mesuré sur ce dépôt (3 familles × 4 hôtes de
|
|
237
|
-
* confiance), garder les blocs porte l'en-tête CSP à ~7,9 Ko sur CHAQUE
|
|
238
|
-
* réponse, contre ~2,3 Ko une fois les ports connus — au bord des 8 Ko que
|
|
239
|
-
* refusent beaucoup de relais.
|
|
240
|
-
*
|
|
241
|
-
* Développement seulement : `startDev` ne tourne pas en production. La
|
|
242
|
-
* garantie reste une liste d'origines nommées — jamais un `ws:` sans hôte,
|
|
243
|
-
* qui la supprimerait au lieu de corriger le symptôme.
|
|
244
|
-
*
|
|
245
|
-
* @returns ports en chaîne, dédupliqués ; repli `devPort` si rien n'est connu.
|
|
246
|
-
*/
|
|
247
|
-
private cspPorts;
|
|
152
|
+
renderDocument(entryName: string, nonce?: string): string;
|
|
153
|
+
renderTags(entryName: string, nonce?: string): string;
|
|
248
154
|
}
|
|
249
155
|
export default FrontendService;
|
|
@@ -10,17 +10,18 @@ import type { IResolvedFrontendEntry } from "../interfaces/IFrontBuilder.js";
|
|
|
10
10
|
*/
|
|
11
11
|
export interface ViteConfigGeneratorOptions {
|
|
12
12
|
/**
|
|
13
|
-
*
|
|
14
|
-
*
|
|
13
|
+
* Chemin de base Vite en développement — `/_vite/<famille>/`
|
|
14
|
+
* (`devBasePath`). Émis comme `base` : Vite préfixe alors TOUTES ses URLs
|
|
15
|
+
* (modules, assets, `url()` CSS, socket HMR), et Nodefony relaie ce préfixe
|
|
16
|
+
* vers le serveur Vite.
|
|
15
17
|
*/
|
|
16
|
-
readonly
|
|
18
|
+
readonly devBase?: string | undefined;
|
|
17
19
|
/**
|
|
18
|
-
*
|
|
19
|
-
*
|
|
20
|
-
*
|
|
21
|
-
*
|
|
22
|
-
*
|
|
23
|
-
* contre 5151 → 404. Active aussi `strictPort` pour garantir l'origine.
|
|
20
|
+
* @deprecated Utiliser {@link ViteConfigGeneratorOptions.devBase}. Vite
|
|
21
|
+
* réduit un `base` absolu à son seul chemin en développement
|
|
22
|
+
* (`resolveBaseUrl`) : cette origine n'a jamais rendu aucune URL absolue.
|
|
23
|
+
* Sans effet : `strictPort`, qu'elle activait, est désormais toujours posé
|
|
24
|
+
* en développement.
|
|
24
25
|
*/
|
|
25
26
|
readonly viteOrigin?: string | undefined;
|
|
26
27
|
/**
|
|
@@ -32,23 +33,14 @@ export interface ViteConfigGeneratorOptions {
|
|
|
32
33
|
readonly keyPath: string;
|
|
33
34
|
readonly certPath: string;
|
|
34
35
|
} | undefined;
|
|
35
|
-
/**
|
|
36
|
-
* Hôtes acceptés dans le header `Host` (`server.allowedHosts`, Vite ≥6).
|
|
37
|
-
* `true` = tous. Un motif `.suffixe` couvre le domaine et ses sous-domaines.
|
|
38
|
-
* Les IP et `localhost` sont toujours acceptés par Vite — cette liste ne
|
|
39
|
-
* sert que les NOMS (vhosts, `host.docker.internal`, forwarders).
|
|
40
|
-
*/
|
|
41
|
-
readonly allowedHosts?: true | ReadonlyArray<string> | undefined;
|
|
42
36
|
}
|
|
43
37
|
export declare class ViteConfigGenerator {
|
|
44
38
|
/**
|
|
45
39
|
* Construit le content `.mjs` à écrire à côté de `index.html` du module.
|
|
46
40
|
*
|
|
47
|
-
*
|
|
48
|
-
*
|
|
49
|
-
*
|
|
50
|
-
* relatifs depuis l'app servie par Vite atterrissent sur Vite et reçoivent
|
|
51
|
-
* un SPA-fallback HTML (cause classique de `Unexpected token '<'`).
|
|
41
|
+
* Aucun `server.proxy` : la page est rendue par Nodefony et ses appels d'API
|
|
42
|
+
* partent sur sa propre origine ; Vite ne reçoit que ce que le relais
|
|
43
|
+
* `/_vite/<famille>/` lui transmet (#528).
|
|
52
44
|
*/
|
|
53
45
|
toMjs(entries: ReadonlyArray<IResolvedFrontendEntry>, mode: "development" | "production", opts?: ViteConfigGeneratorOptions): string;
|
|
54
46
|
}
|
|
@@ -1,5 +1,15 @@
|
|
|
1
1
|
import type { IViteSupervisor, IViteSupervisorStatus } from "../interfaces/IViteSupervisor.js";
|
|
2
2
|
import type { IResolvedFrontendEntry } from "../interfaces/IFrontBuilder.js";
|
|
3
|
+
/**
|
|
4
|
+
* Hôte JOIGNABLE pour une adresse d'écoute : `0.0.0.0`/`::` désignent toutes
|
|
5
|
+
* les interfaces, pas une destination — s'y connecter échoue sous Windows. Le
|
|
6
|
+
* superviseur, sa sonde et le proxy inverse joignent Vite depuis la machine
|
|
7
|
+
* qui le lance : la boucle locale est alors toujours juste.
|
|
8
|
+
*
|
|
9
|
+
* @param listenHost - adresse d'écoute (`devHost`)
|
|
10
|
+
* @returns l'hôte à joindre
|
|
11
|
+
*/
|
|
12
|
+
export declare function browserReachableHost(listenHost: string): string;
|
|
3
13
|
/**
|
|
4
14
|
* Logger minimal — injecté par FrontendService pour piper les logs Vite
|
|
5
15
|
* dans le syslog Nodefony sans dépendance dure sur Service.
|
|
@@ -13,27 +23,14 @@ export interface ViteSupervisorOptions {
|
|
|
13
23
|
readonly devHost: string;
|
|
14
24
|
readonly devPort: number;
|
|
15
25
|
/**
|
|
16
|
-
*
|
|
17
|
-
*
|
|
18
|
-
* de `devHost:port`. Dissocie ce que Vite ÉCOUTE de ce que le navigateur
|
|
19
|
-
* APPELLE (forwarder Codespaces/Gitpod, `host.docker.internal`, remap).
|
|
26
|
+
* Chemin de base Vite de l'instance (`devBasePath(famille)`) — émis comme
|
|
27
|
+
* `base` dans la config générée, rendu par `status().base`.
|
|
20
28
|
*/
|
|
21
|
-
readonly
|
|
22
|
-
/**
|
|
23
|
-
* Hôtes que Vite doit accepter dans le header `Host` (`server.allowedHosts`).
|
|
24
|
-
* `true` = tous. Dérivé par FrontendService de la liste `trustedHosts` http —
|
|
25
|
-
* jamais maintenu ici (1 règle = 1 implémentation).
|
|
26
|
-
*/
|
|
27
|
-
readonly allowedHosts?: true | ReadonlyArray<string> | undefined;
|
|
29
|
+
readonly devBase?: string | undefined;
|
|
28
30
|
readonly startupTimeoutMs: number;
|
|
29
31
|
readonly pipeLogs: boolean;
|
|
30
32
|
readonly cwd: string;
|
|
31
33
|
readonly logger: IViteSupervisorLogger;
|
|
32
|
-
/**
|
|
33
|
-
* Origine du serveur Nodefony pour `server.proxy` côté Vite — ex `"http://127.0.0.1:5151"`.
|
|
34
|
-
* Quand fourni, les paths `apiProxyPaths` des entries sont proxifiés vers ce backend.
|
|
35
|
-
*/
|
|
36
|
-
readonly backendOrigin?: string;
|
|
37
34
|
/**
|
|
38
35
|
* Certificats à utiliser si Vite doit servir en HTTPS. Paths absolus vers les
|
|
39
36
|
* fichiers PEM — les mêmes que Nodefony utilise pour son `server-https` (5152).
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
import type { IBootNotice } from "nodefony";
|
|
2
|
+
import type { IViteSupervisorStatus } from "../interfaces/IViteSupervisor.js";
|
|
3
|
+
/** Ce que le frontend dit au bilan de démarrage. */
|
|
4
|
+
export interface IFrontendBootSummary {
|
|
5
|
+
/** Instances Vite réellement prêtes. */
|
|
6
|
+
ready: number;
|
|
7
|
+
/**
|
|
8
|
+
* Une ligne par instance : les bundles qu'elle sert et son port INTERNE
|
|
9
|
+
* (`react, studio · Vite interne :5173`) — jamais présenté comme une adresse
|
|
10
|
+
* à ouvrir : Vite passe derrière Nodefony, on ouvre l'application.
|
|
11
|
+
*/
|
|
12
|
+
lines: string[];
|
|
13
|
+
/** Le point d'attention à déclarer, ou `null` si tout est servi. */
|
|
14
|
+
notice: IBootNotice | null;
|
|
15
|
+
}
|
|
16
|
+
/**
|
|
17
|
+
* Résume les instances Vite pour le bilan de démarrage — fonction PURE (les
|
|
18
|
+
* statuts sont lus par l'appelant), éprouvable sans lancer Vite.
|
|
19
|
+
*
|
|
20
|
+
* @param statuses - l'état de chaque superviseur Vite, après démarrage.
|
|
21
|
+
* @returns lignes de détail, nombre d'instances prêtes, point d'attention.
|
|
22
|
+
*/
|
|
23
|
+
export declare function summarizeFrontendBoot(statuses: readonly IViteSupervisorStatus[]): IFrontendBootSummary;
|