@cadence-app/compiler 0.3.0 → 0.5.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/README.md +2 -2
- package/dist/app-assets.d.ts +19 -0
- package/dist/app-assets.js +41 -0
- package/dist/build.d.ts +2 -0
- package/dist/build.js +31 -16
- package/dist/cli.js +133 -12
- package/dist/dev-channel-client.d.ts +61 -0
- package/dist/dev-channel-client.js +168 -0
- package/dist/dev-channel-session.d.ts +46 -0
- package/dist/dev-channel-session.js +113 -0
- package/dist/dev-deep-link.d.ts +22 -0
- package/dist/dev-deep-link.js +45 -0
- package/dist/dev-scaffold.d.ts +12 -0
- package/dist/dev-scaffold.js +16 -0
- package/dist/dev-server.d.ts +17 -0
- package/dist/dev-server.js +118 -7
- package/dist/host/browser-mock-host.js +3 -0
- package/dist/host/dev-client.js +3 -1
- package/dist/host/engine-entry.js +35 -0
- package/dist/index.d.ts +5 -1
- package/dist/index.js +3 -1
- package/dist/local-addresses.d.ts +10 -0
- package/dist/local-addresses.js +23 -0
- package/dist/pairing-token.d.ts +40 -0
- package/dist/pairing-token.js +76 -0
- package/dist/project-tooling.js +7 -0
- package/dist/qr/galois.d.ts +9 -0
- package/dist/qr/galois.js +48 -0
- package/dist/qr/matrix.d.ts +9 -0
- package/dist/qr/matrix.js +316 -0
- package/dist/qr/qr-code.d.ts +19 -0
- package/dist/qr/qr-code.js +131 -0
- package/dist/qr/qr-error.d.ts +4 -0
- package/dist/qr/qr-error.js +7 -0
- package/dist/qr/terminal-render.d.ts +8 -0
- package/dist/qr/terminal-render.js +59 -0
- package/dist/template/parser.d.ts +2 -0
- package/dist/template/parser.js +2 -1
- package/package.json +5 -5
|
@@ -0,0 +1,113 @@
|
|
|
1
|
+
import { createHash } from 'node:crypto';
|
|
2
|
+
import { readFile, readdir } from 'node:fs/promises';
|
|
3
|
+
import path from 'node:path';
|
|
4
|
+
import { DEV_SCAFFOLD_FILES } from "./dev-scaffold.js";
|
|
5
|
+
import { contentTypeFor } from "./dev-server.js";
|
|
6
|
+
import { readCredentials } from "./publish/credentials.js";
|
|
7
|
+
import { DevChannelClient } from "./dev-channel-client.js";
|
|
8
|
+
import { DistributionClient } from "./publish/distribution-client.js";
|
|
9
|
+
import { NotAuthenticatedError } from "./publish/publish-errors.js";
|
|
10
|
+
/**
|
|
11
|
+
* Ouvre un canal de développement et rend de quoi l'alimenter (ADR-038).
|
|
12
|
+
*
|
|
13
|
+
* Le canal ne crée aucune version, et rien de ce qu'il porte ne s'installe sur
|
|
14
|
+
* l'appareil : ce qui tient la place d'une signature est l'éphémère.
|
|
15
|
+
*/
|
|
16
|
+
export async function openDevChannel(options) {
|
|
17
|
+
const credentials = options.credentials ?? (await readCredentials());
|
|
18
|
+
if (credentials === null) {
|
|
19
|
+
throw new NotAuthenticatedError();
|
|
20
|
+
}
|
|
21
|
+
const client = options.createClient?.(credentials) ?? new DevChannelClient(credentials);
|
|
22
|
+
const appId = options.appId ?? (await resolveAppId(options, credentials));
|
|
23
|
+
const channel = await client.open(appId);
|
|
24
|
+
return {
|
|
25
|
+
code: channel.code,
|
|
26
|
+
displayCode: channel.displayCode,
|
|
27
|
+
pollUrl: channel.pollUrl,
|
|
28
|
+
expiresAt: channel.expiresAt,
|
|
29
|
+
async push(manifest) {
|
|
30
|
+
const files = await readBundleFiles(options.distDir);
|
|
31
|
+
const declared = integrityMap(files);
|
|
32
|
+
const pushed = await client.pushBundle(channel.code, { ...manifest, assets: declared });
|
|
33
|
+
const byPath = new Map(files.map((file) => [file.relativePath, file]));
|
|
34
|
+
let uploadedBytes = 0;
|
|
35
|
+
const uploaded = [];
|
|
36
|
+
for (const missing of pushed.missingAssets) {
|
|
37
|
+
const file = byPath.get(missing) ?? byPath.get(`assets/${missing}`);
|
|
38
|
+
if (file === undefined) {
|
|
39
|
+
/* Le serveur réclame un chemin que ce bundle ne déclare pas : se taire
|
|
40
|
+
laisserait l'appareil servir des octets d'une compilation d'avant. */
|
|
41
|
+
throw new Error(`le canal réclame « ${missing} », que le bundle compilé ne contient pas`);
|
|
42
|
+
}
|
|
43
|
+
await client.putAsset(channel.code, file.relativePath, file.bytes, contentTypeFor(file.relativePath));
|
|
44
|
+
uploaded.push(file.relativePath);
|
|
45
|
+
uploadedBytes += file.bytes.byteLength;
|
|
46
|
+
}
|
|
47
|
+
return {
|
|
48
|
+
version: pushed.version,
|
|
49
|
+
declared: files.length,
|
|
50
|
+
uploaded,
|
|
51
|
+
uploadedBytes,
|
|
52
|
+
};
|
|
53
|
+
},
|
|
54
|
+
async reportError(message) {
|
|
55
|
+
await client.reportError(channel.code, message);
|
|
56
|
+
},
|
|
57
|
+
};
|
|
58
|
+
}
|
|
59
|
+
async function resolveAppId(options, credentials) {
|
|
60
|
+
if (options.resolveAppId !== undefined) {
|
|
61
|
+
return options.resolveAppId(credentials, options.slug);
|
|
62
|
+
}
|
|
63
|
+
const app = await new DistributionClient(credentials).findAppBySlug(options.slug);
|
|
64
|
+
return app.id;
|
|
65
|
+
}
|
|
66
|
+
/**
|
|
67
|
+
* Les fichiers que le canal doit porter : exactement ceux de l'archive
|
|
68
|
+
* publiée, l'échafaudage du navigateur exclu par le même ensemble.
|
|
69
|
+
*/
|
|
70
|
+
async function readBundleFiles(distDir) {
|
|
71
|
+
const files = [];
|
|
72
|
+
await collectFiles(distDir, '', files);
|
|
73
|
+
rejectColliding(files);
|
|
74
|
+
return files;
|
|
75
|
+
}
|
|
76
|
+
async function collectFiles(directory, prefix, collected) {
|
|
77
|
+
const entries = await readdir(directory, { withFileTypes: true });
|
|
78
|
+
for (const entry of entries) {
|
|
79
|
+
const relativePath = prefix === '' ? entry.name : `${prefix}/${entry.name}`;
|
|
80
|
+
if (DEV_SCAFFOLD_FILES.has(relativePath)) {
|
|
81
|
+
continue;
|
|
82
|
+
}
|
|
83
|
+
const entryPath = path.join(directory, entry.name);
|
|
84
|
+
if (entry.isDirectory()) {
|
|
85
|
+
await collectFiles(entryPath, relativePath, collected);
|
|
86
|
+
continue;
|
|
87
|
+
}
|
|
88
|
+
const bytes = await readFile(entryPath);
|
|
89
|
+
collected.push({ relativePath, bytes, sha256: sha256Hex(bytes) });
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
function integrityMap(files) {
|
|
93
|
+
return Object.fromEntries(files.map((file) => [file.relativePath, { sha256: file.sha256, size: file.bytes.byteLength }]));
|
|
94
|
+
}
|
|
95
|
+
/**
|
|
96
|
+
* Le serveur retire un préfixe `assets/` du chemin déclaré : `assets/logo.png`
|
|
97
|
+
* et `logo.png` y deviennent une seule clé, et le second écrirait sur le
|
|
98
|
+
* premier. Mieux vaut refuser que servir un fichier pour un autre.
|
|
99
|
+
*/
|
|
100
|
+
function rejectColliding(files) {
|
|
101
|
+
const claimed = new Map();
|
|
102
|
+
for (const file of files) {
|
|
103
|
+
const key = file.relativePath.replace(/^assets\//, '');
|
|
104
|
+
const previous = claimed.get(key);
|
|
105
|
+
if (previous !== undefined) {
|
|
106
|
+
throw new Error(`« ${previous} » et « ${file.relativePath} » tiennent la même place dans un canal de développement`);
|
|
107
|
+
}
|
|
108
|
+
claimed.set(key, file.relativePath);
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
function sha256Hex(bytes) {
|
|
112
|
+
return createHash('sha256').update(bytes).digest('hex');
|
|
113
|
+
}
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Le lien que porte le QR : l'adresse du serveur, telle que le conteneur la
|
|
3
|
+
* composera ensuite.
|
|
4
|
+
*
|
|
5
|
+
* L'adresse n'est pas encodée. `:` et `/` sont permis dans une query, et un
|
|
6
|
+
* `%3A` de plus par caractère ferait grossir le QR pour rien — une adresse de
|
|
7
|
+
* serveur de développement ne porte ni `&` ni `=`.
|
|
8
|
+
*
|
|
9
|
+
* La barre oblique avant la query n'est pas décorative : un lien au chemin vide
|
|
10
|
+
* se lit différemment d'un cadre d'hôte à l'autre, et plusieurs n'en tirent
|
|
11
|
+
* alors aucune route.
|
|
12
|
+
*/
|
|
13
|
+
export declare function pairingDeepLink(baseUrl: string): string;
|
|
14
|
+
/**
|
|
15
|
+
* Le lien que porte le QR d'un canal de développement : l'adresse que
|
|
16
|
+
* l'appareil interrogera (ADR-038).
|
|
17
|
+
*
|
|
18
|
+
* Même forme et mêmes raisons que celle d'un serveur local, au paramètre près.
|
|
19
|
+
* Le code court reste la voie sans appareil photo ; ce lien est celle qui
|
|
20
|
+
* épargne de le recopier.
|
|
21
|
+
*/
|
|
22
|
+
export declare function channelDeepLink(pollUrl: string): string;
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Le schéma que les hôtes de démonstration enregistrent pour recevoir une
|
|
3
|
+
* adresse de serveur de développement.
|
|
4
|
+
*
|
|
5
|
+
* Un seul schéma pour les deux hôtes : installer les deux sur le même
|
|
6
|
+
* téléphone fait demander lequel ouvrir, ce qui est la bonne réponse. Une
|
|
7
|
+
* super-app réelle choisit le sien.
|
|
8
|
+
*/
|
|
9
|
+
const PAIRING_SCHEME = 'cadence-dev';
|
|
10
|
+
const PAIRING_ACTION = 'pair';
|
|
11
|
+
const PAIRING_URL_PARAMETER = 'url';
|
|
12
|
+
/**
|
|
13
|
+
* Un canal se nomme par un paramètre à lui, et non par la même adresse.
|
|
14
|
+
*
|
|
15
|
+
* Les deux portent une adresse `http(s)`, donc rien dans sa forme ne les
|
|
16
|
+
* distingue. Laisser l'hôte deviner le ferait ouvrir sa WebView sur ce qu'on
|
|
17
|
+
* lui montre, ce qu'ADR-036 refuse déjà pour la saisie. Le lien le dit.
|
|
18
|
+
*/
|
|
19
|
+
const PAIRING_CHANNEL_PARAMETER = 'channel';
|
|
20
|
+
/**
|
|
21
|
+
* Le lien que porte le QR : l'adresse du serveur, telle que le conteneur la
|
|
22
|
+
* composera ensuite.
|
|
23
|
+
*
|
|
24
|
+
* L'adresse n'est pas encodée. `:` et `/` sont permis dans une query, et un
|
|
25
|
+
* `%3A` de plus par caractère ferait grossir le QR pour rien — une adresse de
|
|
26
|
+
* serveur de développement ne porte ni `&` ni `=`.
|
|
27
|
+
*
|
|
28
|
+
* La barre oblique avant la query n'est pas décorative : un lien au chemin vide
|
|
29
|
+
* se lit différemment d'un cadre d'hôte à l'autre, et plusieurs n'en tirent
|
|
30
|
+
* alors aucune route.
|
|
31
|
+
*/
|
|
32
|
+
export function pairingDeepLink(baseUrl) {
|
|
33
|
+
return `${PAIRING_SCHEME}://${PAIRING_ACTION}/?${PAIRING_URL_PARAMETER}=${baseUrl}`;
|
|
34
|
+
}
|
|
35
|
+
/**
|
|
36
|
+
* Le lien que porte le QR d'un canal de développement : l'adresse que
|
|
37
|
+
* l'appareil interrogera (ADR-038).
|
|
38
|
+
*
|
|
39
|
+
* Même forme et mêmes raisons que celle d'un serveur local, au paramètre près.
|
|
40
|
+
* Le code court reste la voie sans appareil photo ; ce lien est celle qui
|
|
41
|
+
* épargne de le recopier.
|
|
42
|
+
*/
|
|
43
|
+
export function channelDeepLink(pollUrl) {
|
|
44
|
+
return `${PAIRING_SCHEME}://${PAIRING_ACTION}/?${PAIRING_CHANNEL_PARAMETER}=${pollUrl}`;
|
|
45
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
/** Le document que le conteneur demande, et le seul que l'archive embarque. */
|
|
2
|
+
export declare const ENTRY_DOCUMENT = "index.html";
|
|
3
|
+
/** Le document que `mini dev` sert au navigateur, avec son mock natif. */
|
|
4
|
+
export declare const DEV_SHELL_FILE = "dev.html";
|
|
5
|
+
export declare const DEV_HOST_ENTRY = "dev-host";
|
|
6
|
+
export declare const DEV_CLIENT_ENTRY = "dev-client";
|
|
7
|
+
/**
|
|
8
|
+
* L'échafaudage que `mini dev` sert dans le navigateur. Il reste dans `outDir`,
|
|
9
|
+
* mais l'archive part sur le serveur de distribution et jusque sur les
|
|
10
|
+
* appareils : elle n'embarque que ce que le conteneur exécute.
|
|
11
|
+
*/
|
|
12
|
+
export declare const DEV_SCAFFOLD_FILES: ReadonlySet<string>;
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
/** Le document que le conteneur demande, et le seul que l'archive embarque. */
|
|
2
|
+
export const ENTRY_DOCUMENT = 'index.html';
|
|
3
|
+
/** Le document que `mini dev` sert au navigateur, avec son mock natif. */
|
|
4
|
+
export const DEV_SHELL_FILE = 'dev.html';
|
|
5
|
+
export const DEV_HOST_ENTRY = 'dev-host';
|
|
6
|
+
export const DEV_CLIENT_ENTRY = 'dev-client';
|
|
7
|
+
/**
|
|
8
|
+
* L'échafaudage que `mini dev` sert dans le navigateur. Il reste dans `outDir`,
|
|
9
|
+
* mais l'archive part sur le serveur de distribution et jusque sur les
|
|
10
|
+
* appareils : elle n'embarque que ce que le conteneur exécute.
|
|
11
|
+
*/
|
|
12
|
+
export const DEV_SCAFFOLD_FILES = new Set([
|
|
13
|
+
DEV_SHELL_FILE,
|
|
14
|
+
`${DEV_HOST_ENTRY}.js`,
|
|
15
|
+
`${DEV_CLIENT_ENTRY}.js`,
|
|
16
|
+
]);
|
package/dist/dev-server.d.ts
CHANGED
|
@@ -6,8 +6,25 @@ export interface DevServerOptions {
|
|
|
6
6
|
}
|
|
7
7
|
export interface DevServer {
|
|
8
8
|
readonly url: string;
|
|
9
|
+
/**
|
|
10
|
+
* Les mêmes pages, atteintes depuis le réseau local : `listen` sans hôte
|
|
11
|
+
* écoute déjà toutes les interfaces, un appareil du même Wi-Fi y répond donc
|
|
12
|
+
* sans rien de plus. Vide sur une machine sans interface externe.
|
|
13
|
+
*
|
|
14
|
+
* Elles portent le jeton, parce qu'elles en ont besoin pour répondre.
|
|
15
|
+
*/
|
|
16
|
+
readonly networkUrls: readonly string[];
|
|
17
|
+
/** Le jeton que ce serveur exige de tout appareil qui n'est pas la machine. */
|
|
18
|
+
readonly pairingToken: string;
|
|
9
19
|
close(): void;
|
|
10
20
|
}
|
|
21
|
+
/**
|
|
22
|
+
* Le type MIME d'un fichier servi, `application/octet-stream` à défaut.
|
|
23
|
+
*
|
|
24
|
+
* Exporté parce que le canal de développement doit étiqueter les mêmes
|
|
25
|
+
* fichiers (ADR-038) : deux tables divergeraient.
|
|
26
|
+
*/
|
|
27
|
+
export declare function contentTypeFor(filePath: string): string;
|
|
11
28
|
/**
|
|
12
29
|
* Serveur `mini dev` : sert le bundle compilé, surveille les sources du
|
|
13
30
|
* mini-programme et pousse un événement SSE de rechargement après chaque
|
package/dist/dev-server.js
CHANGED
|
@@ -1,7 +1,17 @@
|
|
|
1
1
|
import { existsSync, watch } from 'node:fs';
|
|
2
2
|
import { readFile } from 'node:fs/promises';
|
|
3
3
|
import http from 'node:http';
|
|
4
|
+
import os from 'node:os';
|
|
4
5
|
import path from 'node:path';
|
|
6
|
+
import { DEV_CLIENT_ENTRY, DEV_SHELL_FILE, ENTRY_DOCUMENT } from "./dev-scaffold.js";
|
|
7
|
+
import { dialableAddresses } from "./local-addresses.js";
|
|
8
|
+
import { mintPairingToken, pairingPathPrefix, pairingRefusal, splitPairingToken, } from "./pairing-token.js";
|
|
9
|
+
class DevServerError extends Error {
|
|
10
|
+
constructor(message) {
|
|
11
|
+
super(message);
|
|
12
|
+
this.name = 'DevServerError';
|
|
13
|
+
}
|
|
14
|
+
}
|
|
5
15
|
const CONTENT_TYPES = {
|
|
6
16
|
'.html': 'text/html; charset=utf-8',
|
|
7
17
|
'.js': 'text/javascript; charset=utf-8',
|
|
@@ -10,9 +20,59 @@ const CONTENT_TYPES = {
|
|
|
10
20
|
'.png': 'image/png',
|
|
11
21
|
'.jpg': 'image/jpeg',
|
|
12
22
|
'.svg': 'image/svg+xml',
|
|
23
|
+
'.webp': 'image/webp',
|
|
24
|
+
'.avif': 'image/avif',
|
|
25
|
+
'.txt': 'text/plain; charset=utf-8',
|
|
26
|
+
'.woff2': 'font/woff2',
|
|
27
|
+
'.woff': 'font/woff',
|
|
13
28
|
'.zip': 'application/zip',
|
|
14
29
|
};
|
|
30
|
+
/**
|
|
31
|
+
* Le type MIME d'un fichier servi, `application/octet-stream` à défaut.
|
|
32
|
+
*
|
|
33
|
+
* Exporté parce que le canal de développement doit étiqueter les mêmes
|
|
34
|
+
* fichiers (ADR-038) : deux tables divergeraient.
|
|
35
|
+
*/
|
|
36
|
+
export function contentTypeFor(filePath) {
|
|
37
|
+
return CONTENT_TYPES[path.extname(filePath)] ?? 'application/octet-stream';
|
|
38
|
+
}
|
|
15
39
|
const REBUILD_DEBOUNCE_MS = 150;
|
|
40
|
+
const RELOAD_ENDPOINT = '/__cadence_dev';
|
|
41
|
+
/**
|
|
42
|
+
* Combien de fois le mini-programme a été recompilé depuis le démarrage.
|
|
43
|
+
*
|
|
44
|
+
* Un conteneur qui sert ses octets lui-même n'a pas de page où brancher le
|
|
45
|
+
* canal poussé : la WebView ne parle qu'à lui, et il ne sait pas tenir un flux
|
|
46
|
+
* ouvert à travers son interception de requêtes. Il demande donc ce compteur, et
|
|
47
|
+
* recharge quand il change (ADR-035).
|
|
48
|
+
*/
|
|
49
|
+
const BUILD_COUNT_ENDPOINT = `${RELOAD_ENDPOINT}/builds`;
|
|
50
|
+
/**
|
|
51
|
+
* Ce que la page raconte sur l'appareil, rapporté ici.
|
|
52
|
+
*
|
|
53
|
+
* Un GET, et non un envoi : le seul HTTP dont un conteneur dispose est celui
|
|
54
|
+
* que le SDK lui injecte, et ce point d'injection rapporte des octets. Lui
|
|
55
|
+
* adjoindre un verbe demanderait un client par plateforme, pour une ligne de
|
|
56
|
+
* journal sur une machine locale (ADR-037).
|
|
57
|
+
*/
|
|
58
|
+
const CONSOLE_ENDPOINT = `${RELOAD_ENDPOINT}/console`;
|
|
59
|
+
const CONSOLE_PARAMETER = 'line';
|
|
60
|
+
const DEVICE_PREFIX = '[appareil]';
|
|
61
|
+
const LONGEST_CONSOLE_LINE = 2000;
|
|
62
|
+
const BODY_END = '</body>';
|
|
63
|
+
const LIVE_RELOAD_TAG = `<script src="./${DEV_CLIENT_ENTRY}.js"></script>`;
|
|
64
|
+
/**
|
|
65
|
+
* Le conteneur demande le document de production, celui que l'archive embarque
|
|
66
|
+
* et qui ne porte aucun échafaudage. Le rechargement lui vient donc du serveur,
|
|
67
|
+
* à la seconde où il sert la page, et non du bundle : ce qui tourne sur
|
|
68
|
+
* l'appareil reste octet pour octet ce qui sera publié.
|
|
69
|
+
*/
|
|
70
|
+
function withLiveReloadClient(document) {
|
|
71
|
+
if (!document.includes(BODY_END)) {
|
|
72
|
+
throw new DevServerError(`${ENTRY_DOCUMENT} ne contient pas ${BODY_END} : impossible d'y brancher le rechargement`);
|
|
73
|
+
}
|
|
74
|
+
return document.replace(BODY_END, ` ${LIVE_RELOAD_TAG}\n ${BODY_END}`);
|
|
75
|
+
}
|
|
16
76
|
/**
|
|
17
77
|
* Serveur `mini dev` : sert le bundle compilé, surveille les sources du
|
|
18
78
|
* mini-programme et pousse un événement SSE de rechargement après chaque
|
|
@@ -20,12 +80,55 @@ const REBUILD_DEBOUNCE_MS = 150;
|
|
|
20
80
|
*/
|
|
21
81
|
export function startDevServer(options) {
|
|
22
82
|
const sseClients = new Set();
|
|
83
|
+
const pairingToken = mintPairingToken();
|
|
84
|
+
let completedBuilds = 0;
|
|
85
|
+
const servedRoot = options.distDir.endsWith(path.sep)
|
|
86
|
+
? options.distDir
|
|
87
|
+
: `${options.distDir}${path.sep}`;
|
|
23
88
|
const server = http.createServer((request, response) => {
|
|
24
|
-
|
|
89
|
+
handleRequest(request, response).catch((error) => {
|
|
90
|
+
const message = error instanceof Error ? error.message : String(error);
|
|
91
|
+
console.error('[cadence dev]', message);
|
|
92
|
+
if (!response.headersSent) {
|
|
93
|
+
response.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
|
|
94
|
+
}
|
|
95
|
+
response.end(`500 — ${message}`);
|
|
96
|
+
});
|
|
25
97
|
});
|
|
26
98
|
async function handleRequest(request, response) {
|
|
27
|
-
const
|
|
28
|
-
|
|
99
|
+
const [requestPath = '/', query = ''] = (request.url ?? '/').split('?');
|
|
100
|
+
const requested = splitPairingToken(requestPath);
|
|
101
|
+
const refusal = pairingRefusal({
|
|
102
|
+
expected: pairingToken,
|
|
103
|
+
presented: requested.token,
|
|
104
|
+
peer: request.socket.remoteAddress,
|
|
105
|
+
});
|
|
106
|
+
if (refusal !== null) {
|
|
107
|
+
response.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
|
|
108
|
+
response.end(`403 — ${refusal}`);
|
|
109
|
+
return;
|
|
110
|
+
}
|
|
111
|
+
if (requested.path === CONSOLE_ENDPOINT) {
|
|
112
|
+
const line = new URLSearchParams(query).get(CONSOLE_PARAMETER) ?? '';
|
|
113
|
+
console.warn(`${DEVICE_PREFIX} ${line.slice(0, LONGEST_CONSOLE_LINE)}`);
|
|
114
|
+
/* 200 et non 204 : le conteneur lit par le téléchargeur du SDK, qui
|
|
115
|
+
refuse tout ce qui n'est pas un corps complet. */
|
|
116
|
+
response.writeHead(200, {
|
|
117
|
+
'Content-Type': 'text/plain; charset=utf-8',
|
|
118
|
+
'Cache-Control': 'no-store',
|
|
119
|
+
});
|
|
120
|
+
response.end('ok');
|
|
121
|
+
return;
|
|
122
|
+
}
|
|
123
|
+
if (requested.path === BUILD_COUNT_ENDPOINT) {
|
|
124
|
+
response.writeHead(200, {
|
|
125
|
+
'Content-Type': 'text/plain; charset=utf-8',
|
|
126
|
+
'Cache-Control': 'no-store',
|
|
127
|
+
});
|
|
128
|
+
response.end(String(completedBuilds));
|
|
129
|
+
return;
|
|
130
|
+
}
|
|
131
|
+
if (requested.path === RELOAD_ENDPOINT) {
|
|
29
132
|
response.writeHead(200, {
|
|
30
133
|
'Content-Type': 'text/event-stream',
|
|
31
134
|
'Cache-Control': 'no-cache',
|
|
@@ -36,16 +139,21 @@ export function startDevServer(options) {
|
|
|
36
139
|
request.on('close', () => sseClients.delete(response));
|
|
37
140
|
return;
|
|
38
141
|
}
|
|
39
|
-
const relativePath =
|
|
142
|
+
const relativePath = requested.path === '/' ? DEV_SHELL_FILE : requested.path.slice(1);
|
|
40
143
|
const filePath = path.join(options.distDir, relativePath);
|
|
41
|
-
if (!filePath.startsWith(
|
|
144
|
+
if (!filePath.startsWith(servedRoot) || !existsSync(filePath)) {
|
|
42
145
|
response.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
|
|
43
146
|
response.end(`404 — ${relativePath}`);
|
|
44
147
|
return;
|
|
45
148
|
}
|
|
46
|
-
|
|
149
|
+
/* Le corps est prêt avant l'en-tête : un document d'entrée où brancher le
|
|
150
|
+
rechargement échoue répond 500, et non 200 suivi d'un silence. */
|
|
151
|
+
const body = relativePath === ENTRY_DOCUMENT
|
|
152
|
+
? withLiveReloadClient(await readFile(filePath, 'utf8'))
|
|
153
|
+
: await readFile(filePath);
|
|
154
|
+
const contentType = contentTypeFor(filePath);
|
|
47
155
|
response.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': 'no-store' });
|
|
48
|
-
response.end(
|
|
156
|
+
response.end(body);
|
|
49
157
|
}
|
|
50
158
|
let rebuildTimer = null;
|
|
51
159
|
const watcher = watch(options.watchDir, { recursive: true }, (_event, fileName) => {
|
|
@@ -59,6 +167,7 @@ export function startDevServer(options) {
|
|
|
59
167
|
options
|
|
60
168
|
.rebuild()
|
|
61
169
|
.then(() => {
|
|
170
|
+
completedBuilds += 1;
|
|
62
171
|
console.warn(`[cadence dev] rebuild ok (${fileName ?? 'watch'})`);
|
|
63
172
|
for (const client of sseClients) {
|
|
64
173
|
client.write('event: reload\ndata: {}\n\n');
|
|
@@ -70,6 +179,8 @@ export function startDevServer(options) {
|
|
|
70
179
|
server.listen(options.port);
|
|
71
180
|
return {
|
|
72
181
|
url: `http://localhost:${options.port}/`,
|
|
182
|
+
networkUrls: dialableAddresses(os.networkInterfaces()).map((host) => `http://${host}:${options.port}${pairingPathPrefix(pairingToken)}`),
|
|
183
|
+
pairingToken,
|
|
73
184
|
close() {
|
|
74
185
|
watcher.close();
|
|
75
186
|
for (const client of sseClients) {
|
|
@@ -144,6 +144,9 @@ host.handle(BridgeMethods.appReportError, (payload) => {
|
|
|
144
144
|
console.error(`[cadence miniapp] ${source} — ${message}`, stack ?? '');
|
|
145
145
|
return null;
|
|
146
146
|
});
|
|
147
|
+
/* Un navigateur n'a pas d'écran d'ouverture à lever. L'appel est tout de même
|
|
148
|
+
accepté : un refus ferait écrire au moteur une erreur qui n'en est pas une. */
|
|
149
|
+
host.handle(BridgeMethods.appPageRendered, () => null);
|
|
147
150
|
host.handle(BridgeMethods.navSetChrome, (payload) => {
|
|
148
151
|
document.title = payload.title;
|
|
149
152
|
return null;
|
package/dist/host/dev-client.js
CHANGED
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
"use strict";
|
|
2
|
-
|
|
2
|
+
/* Relative, et non absolue : l'adresse d'un appareil apparié porte un
|
|
3
|
+
préfixe de jeton, que le calcul du navigateur reconduit tout seul. */
|
|
4
|
+
const events = new EventSource('./__cadence_dev');
|
|
3
5
|
events.addEventListener('reload', () => location.reload());
|
|
4
6
|
events.addEventListener('error', () => {
|
|
5
7
|
/* le serveur dev est parti ; EventSource retentera tout seul */
|
|
@@ -110,6 +110,40 @@ function announceEntryChrome(nativeApi, manifest) {
|
|
|
110
110
|
console.error('[cadence] the container did not take the entry chrome', error);
|
|
111
111
|
});
|
|
112
112
|
}
|
|
113
|
+
/**
|
|
114
|
+
* Dit au conteneur que la page d'entrée est peinte, et une seule fois.
|
|
115
|
+
*
|
|
116
|
+
* C'est le signal qui lève un écran d'ouverture. `nav.setChrome` part **avant**
|
|
117
|
+
* le rendu — un conteneur qui s'en sert découvre une WebView encore vide.
|
|
118
|
+
*/
|
|
119
|
+
function announcePageRendered(nativeApi) {
|
|
120
|
+
afterTheNextPaint(() => {
|
|
121
|
+
/* Un conteneur qui ne connaît pas la méthode rejette l'appel, et c'est son
|
|
122
|
+
droit : le moteur n'a rien à faire de la réponse. */
|
|
123
|
+
void nativeApi.app.pageRendered().catch(() => undefined);
|
|
124
|
+
});
|
|
125
|
+
}
|
|
126
|
+
/**
|
|
127
|
+
* Appelle `onPainted` une fois la frame suivante passée à l'écran.
|
|
128
|
+
*
|
|
129
|
+
* Le rappel de `requestAnimationFrame` s'exécute **avant** la peinture de sa
|
|
130
|
+
* frame ; la tâche qu'il programme s'exécute après. C'est la seule façon
|
|
131
|
+
* d'attendre le pixel sans le mesurer.
|
|
132
|
+
*
|
|
133
|
+
* Un document déjà caché n'ordonnance aucune frame, et le repli part alors sur
|
|
134
|
+
* une tâche : le conteneur garderait sinon son écran d'ouverture pour toujours.
|
|
135
|
+
* Rien ne clignote pour autant — une vue qu'on ne regarde pas peint sa page
|
|
136
|
+
* avant qu'on la regarde.
|
|
137
|
+
*/
|
|
138
|
+
function afterTheNextPaint(onPainted) {
|
|
139
|
+
if (typeof requestAnimationFrame !== 'function' || document.hidden) {
|
|
140
|
+
setTimeout(onPainted, 0);
|
|
141
|
+
return;
|
|
142
|
+
}
|
|
143
|
+
requestAnimationFrame(() => {
|
|
144
|
+
setTimeout(onPainted, 0);
|
|
145
|
+
});
|
|
146
|
+
}
|
|
113
147
|
function resolveAppRoot() {
|
|
114
148
|
const existing = document.getElementById('app');
|
|
115
149
|
if (existing !== null) {
|
|
@@ -185,6 +219,7 @@ async function startEngine(manifest, app) {
|
|
|
185
219
|
setActiveRouter(appRouter);
|
|
186
220
|
await appRouter.launch();
|
|
187
221
|
metrics.timeToInteractiveMs = performance.now();
|
|
222
|
+
announcePageRendered(nativeApi);
|
|
188
223
|
}
|
|
189
224
|
const cadenceGlobal = {
|
|
190
225
|
version: ENGINE_VERSION,
|
package/dist/index.d.ts
CHANGED
|
@@ -17,8 +17,12 @@ export { projectToolingFiles } from './project-tooling.js';
|
|
|
17
17
|
export type { InitOptions, InitReport } from './init-project.js';
|
|
18
18
|
export { PROJECT_TEMPLATES, PROJECT_TEMPLATE_NAMES, isProjectTemplateName, } from './project-templates.js';
|
|
19
19
|
export type { ProjectTemplate, ProjectTemplateName } from './project-templates.js';
|
|
20
|
-
export { startDevServer } from './dev-server.js';
|
|
20
|
+
export { startDevServer, contentTypeFor } from './dev-server.js';
|
|
21
21
|
export type { DevServer, DevServerOptions } from './dev-server.js';
|
|
22
|
+
export { DevChannelClient, DevChannelRejectedError } from './dev-channel-client.js';
|
|
23
|
+
export type { DevChannelClientOptions, OpenedDevChannel, PushedBundle, } from './dev-channel-client.js';
|
|
24
|
+
export { openDevChannel } from './dev-channel-session.js';
|
|
25
|
+
export type { DevChannelPush, DevChannelSession, OpenDevChannelOptions, } from './dev-channel-session.js';
|
|
22
26
|
export { credentialsPath, readCredentials, writeCredentials, clearCredentials, normalizeRemoteUrl, } from './publish/credentials.js';
|
|
23
27
|
export type { Credentials } from './publish/credentials.js';
|
|
24
28
|
export { DistributionClient } from './publish/distribution-client.js';
|
package/dist/index.js
CHANGED
|
@@ -10,7 +10,9 @@ export { buildMiniApp, BuildError } from "./build.js";
|
|
|
10
10
|
export { initProject, InitError } from "./init-project.js";
|
|
11
11
|
export { projectToolingFiles } from "./project-tooling.js";
|
|
12
12
|
export { PROJECT_TEMPLATES, PROJECT_TEMPLATE_NAMES, isProjectTemplateName, } from "./project-templates.js";
|
|
13
|
-
export { startDevServer } from "./dev-server.js";
|
|
13
|
+
export { startDevServer, contentTypeFor } from "./dev-server.js";
|
|
14
|
+
export { DevChannelClient, DevChannelRejectedError } from "./dev-channel-client.js";
|
|
15
|
+
export { openDevChannel } from "./dev-channel-session.js";
|
|
14
16
|
export { credentialsPath, readCredentials, writeCredentials, clearCredentials, normalizeRemoteUrl, } from "./publish/credentials.js";
|
|
15
17
|
export { DistributionClient } from "./publish/distribution-client.js";
|
|
16
18
|
export { publishMiniApp } from "./publish/publish-bundle.js";
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
import type { NetworkInterfaceInfo } from 'node:os';
|
|
2
|
+
/**
|
|
3
|
+
* Les adresses IPv4 de cette machine qu'un autre appareil peut composer.
|
|
4
|
+
*
|
|
5
|
+
* Deux refus. Une interface interne ne sort pas de la machine. Et une adresse
|
|
6
|
+
* dont les bits d'hôte sont tous nuls désigne le réseau, pas une machine :
|
|
7
|
+
* macOS en expose une par pont de partage, et elles noieraient la seule
|
|
8
|
+
* adresse utile.
|
|
9
|
+
*/
|
|
10
|
+
export declare function dialableAddresses(interfaces: Readonly<Record<string, NetworkInterfaceInfo[] | undefined>>): readonly string[];
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Les adresses IPv4 de cette machine qu'un autre appareil peut composer.
|
|
3
|
+
*
|
|
4
|
+
* Deux refus. Une interface interne ne sort pas de la machine. Et une adresse
|
|
5
|
+
* dont les bits d'hôte sont tous nuls désigne le réseau, pas une machine :
|
|
6
|
+
* macOS en expose une par pont de partage, et elles noieraient la seule
|
|
7
|
+
* adresse utile.
|
|
8
|
+
*/
|
|
9
|
+
export function dialableAddresses(interfaces) {
|
|
10
|
+
return Object.values(interfaces)
|
|
11
|
+
.flatMap((addresses) => addresses ?? [])
|
|
12
|
+
.filter((address) => address.family === 'IPv4' && !address.internal)
|
|
13
|
+
.filter((address) => !isNetworkAddress(address.address, address.netmask))
|
|
14
|
+
.map((address) => address.address);
|
|
15
|
+
}
|
|
16
|
+
function isNetworkAddress(address, netmask) {
|
|
17
|
+
const host = toUnsignedInteger(address);
|
|
18
|
+
const network = (host & toUnsignedInteger(netmask)) >>> 0;
|
|
19
|
+
return network === host;
|
|
20
|
+
}
|
|
21
|
+
function toUnsignedInteger(dotted) {
|
|
22
|
+
return dotted.split('.').reduce((value, byte) => value * 256 + Number(byte), 0);
|
|
23
|
+
}
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
/** Ce qu'un chemin demandait, une fois son jeton mis de côté. */
|
|
2
|
+
export interface PairedRequest {
|
|
3
|
+
/** Le jeton que le chemin portait, ou `null` s'il n'en portait pas. */
|
|
4
|
+
readonly token: string | null;
|
|
5
|
+
/** Le chemin sans son préfixe, celui que le serveur résout. */
|
|
6
|
+
readonly path: string;
|
|
7
|
+
}
|
|
8
|
+
/** Une requête à juger : le jeton attendu, celui présenté, et d'où elle vient. */
|
|
9
|
+
export interface PairingCheck {
|
|
10
|
+
readonly expected: string;
|
|
11
|
+
readonly presented: string | null;
|
|
12
|
+
readonly peer: string | undefined;
|
|
13
|
+
}
|
|
14
|
+
/**
|
|
15
|
+
* Un jeton d'appariement, neuf à chaque `mini dev`.
|
|
16
|
+
*
|
|
17
|
+
* Il ne protège rien d'autre que des sources en cours d'écriture, et il meurt
|
|
18
|
+
* avec le serveur : le tirage vaut pour un réseau partagé, pas pour un secret
|
|
19
|
+
* qu'on garde.
|
|
20
|
+
*/
|
|
21
|
+
export declare function mintPairingToken(): string;
|
|
22
|
+
/** Le préfixe de chemin qui porte ce jeton, barre oblique finale comprise. */
|
|
23
|
+
export declare function pairingPathPrefix(token: string): string;
|
|
24
|
+
/**
|
|
25
|
+
* Sépare le jeton du chemin qu'il préfixe.
|
|
26
|
+
*
|
|
27
|
+
* Le jeton vit dans le chemin, et non dans un en-tête ni une query : le
|
|
28
|
+
* conteneur compose l'adresse d'un sous-fichier en ajoutant son nom à celle du
|
|
29
|
+
* document, et un préfixe suit ce calcul sans que personne n'ait à le savoir.
|
|
30
|
+
*/
|
|
31
|
+
export declare function splitPairingToken(requestPath: string): PairedRequest;
|
|
32
|
+
/**
|
|
33
|
+
* Pourquoi cette requête est refusée, `null` quand elle passe.
|
|
34
|
+
*
|
|
35
|
+
* La machine elle-même n'a rien à présenter : le navigateur et l'USB gardent
|
|
36
|
+
* l'adresse courte qu'annonce la documentation. Le jeton n'est exigé que de ce
|
|
37
|
+
* que la boucle locale n'explique pas — un appareil du Wi-Fi, donc aussi la
|
|
38
|
+
* machine du voisin.
|
|
39
|
+
*/
|
|
40
|
+
export declare function pairingRefusal(check: PairingCheck): string | null;
|