turbo-editors/turbo-jspublic Fork 0
v1.0.0
Commits
Clone
git clone https://git.rickub.com/turbo-editors/turbo-js.git
git clone ssh://git@rickub.com/turbo-editors/turbo-js.git

Host key fingerprint (ed25519): SHA256:iycHnxEyq0Q7uyVpB7JlznP0G7JrTPXLYRcAU5CSLhc — verify it before your first connect.

📦 Turbo JS 91999d1 · on v1.0.0 · k33g · 12h ago
javascript-tools.md · 244 lines · 13.1 KBmarkdown
Blame HistoryOpen raw

Référence : outils JavaScript

Description neutre de .turbo-js/tools.toml, du menu JavaScript, et de ce que fait l'exécution d'une commande.

Fichier

Propriété Valeur
Chemin ./.turbo-js/tools.toml
Recherche Le répertoire courant seulement. Les répertoires parents ne sont pas parcourus.
Lecture À chaque ouverture de l'un de ses menus, pour les entrées
Relecture Dès que la taille ou la date de modification du fichier change, pour l'ensemble des menus
Fichier absent Pas une erreur
Fichier illisible Une erreur, affichée dans le menu
Fichier au niveau utilisateur Aucun. Contrairement aux snippets, il n'y a pas de ~/.config/turbo-js/tools.toml.

Format du fichier

Une table [[tool]] par commande.

Clé Type Obligatoire Description
name chaîne oui Ce que le menu affiche. Peut porter une touche chaude entre tildes, comme "~T~est".
command chaîne oui La commande shell à lancer
output chaîne non Où va sa sortie : popup, terminal ou editor. Absent signifie popup.
menu chaîne non Dans quel menu elle apparaît. Absent signifie JavaScript. N'importe quel nom ; le menu est créé pour vous. Peut porter une touche chaude entre tildes.

menu n'est pas vérifié contre une liste, parce qu'il n'y a pas de liste : un nom qu'aucun autre outil n'utilise crée simplement un menu. Un outil sans name, sans command, ou dont l'output nomme quelque chose qui n'existe pas rend tout le fichier erroné. Un output inconnu est refusé plutôt que corrigé : "termnial" aurait sinon l'air d'avoir marché tout en envoyant la sortie ailleurs.

Exemple

[[tool]]
name = "~T~est"
command = "node --test"
output = "popup"

[[tool]]
name = "~E~cho"
command = "echo TADA"
output = "terminal"
menu = "Tools"

Le fichier de départ

JavaScript ▸ Create tools file écrit ces sept outils, dans cet ordre :

Nom Commande Sortie Menu
~I~nstall npm install popup JavaScript
~F~ormat npx prettier --write . popup JavaScript
~L~int npx eslint . popup JavaScript
~T~est node --test popup JavaScript
~R~un node {{script, e.g. main.js}} terminal JavaScript
~S~tart npm start terminal JavaScript
~E~cho echo 🎉 tada! terminal Tools

Install vient en premier parce que c'est la première chose qu'on lance dans un clone frais, et celle qui doit avoir tourné avant qu'aucune des autres ne puisse. L'un d'eux demande une valeur avant de s'exécuter — Run, parce qu'un projet Node n'a pas de point d'entrée unique que l'éditeur pourrait connaître — et un nomme un menu à lui. Ces deux fonctionnalités sont invisibles si le fichier de départ ne les montre pas.

Run et Start reçoivent un terminal : un script peut lire le clavier, et npm start est d'habitude un serveur qu'il faut interrompre par Ctrl-C. Format et Lint passent par npx, qui lance le Prettier et l'ESLint propres au projet quand package.json en dépend et les télécharge dans un cache sinon ; ESLint 9 a besoin d'un eslint.config.js dans le projet. Test est le lanceur de Node lui-même, qui n'a besoin de rien d'installé : il exécute chaque fichier *.test.js, *.spec.js et test/**/*.js sous le répertoire courant.

Il n'y a pas de Build, parce que JavaScript n'a pas d'étape de compilation. node --check {{script}} est la vérification de syntaxe qu'ajoute qui en veut une.

Chaque outil nomme son output, y compris ceux qui nomment le défaut : la clé est la partie intéressante du format, et un fichier où elle apparaît une fois est un fichier où personne ne remarque qu'elle existe.

L'entrée est grisée une fois que le projet a un fichier d'outils, elle ne peut donc pas en écraser un. Le fichier est écrit via un fichier temporaire dans le même répertoire, renommé en place.

Le menu JavaScript

Toujours sur la barre, qu'un fichier d'outils existe ou non. Sa touche chaude est Alt-J.

Entrée Condition
Une ligne par outil sans menu, dans l'ordre du fichier Le fichier en contient au moins un
Cannot read tools, grisé Le fichier est présent mais illisible
Create tools file Le projet n'a pas de fichier d'outils
Open tools file Le projet en a un

Les menus qu'un outil demande

Un menu nommant autre chose que JavaScript met un menu de ce nom sur la barre.

Propriété Valeur
Position Entre JavaScript et Help
Ordre L'ordre dans lequel chaque nom apparaît pour la première fois dans le fichier
Entrées Une ligne par outil nommant ce menu, dans l'ordre du fichier. Rien d'autre — Create tools file et Open tools file restent dans JavaScript.
Fichier illisible Aucun menu du tout ; le menu JavaScript porte l'erreur
Pendant que l'éditeur tourne Ajoutés, retirés et renommés au fil des changements du fichier, sans redémarrage

Touches chaudes

Attribuées automatiquement, parce qu'un nom venu d'un fichier ne peut pas être vérifié à l'avance contre les menus fixes.

Cas Résultat
Pas de tilde dans le nom La première lettre qu'aucun autre menu n'a revendiquée est marquée. Tools devient ~T~ools : T est libre. Format devient For~m~at : F est à File, o à Options, r à Run.
Des tildes nommant une lettre libre Conservés tels quels. Doc~k~er répond à Alt-K.
Des tildes nommant une lettre prise Abandonnés, et une lettre libre choisie à la place. ~F~oo devient F~o~o.
Toutes les lettres prises Pas de touche chaude. F10 et la souris l'ouvrent toujours.

Les lettres que tiennent les menus propres de l'éditeur sont F, E, S, R, C, O, W, N (Snippets), A (Agent), J (JavaScript) et H.

Exécuter une commande

Commun à toutes les sorties :

Propriété Valeur
Shell /bin/sh -c "<commande>" sous Linux et macOS ; cmd.exe /S /C "<commande>" — le shell que nomme %COMSPEC% — sous Windows
Répertoire Le répertoire dans lequel l'éditeur a été lancé
Sortie d'erreur Fusionnée dans la sortie standard, dans l'ordre où la commande les a écrites

Passer par un shell signifie que les tubes, les globs, && et ; marchent tous, un outil peut donc être une séquence. Sous Windows le shell est cmd.exe, qui connaît &&, | et > mais ne développe pas les globs, et où ; n'est pas un séparateur.

output = "popup"

Propriété Valeur
S'ouvre Immédiatement, avant que la commande soit finie
Modal Oui : rien d'autre dans l'éditeur n'est utilisable pendant qu'il est là
Se remplit À mesure que la sortie arrive, en la suivant jusqu'à ce que vous remontiez
Titre pendant l'exécution <commande> — running
Titre une fois fini <commande> — ok, ou <commande> — exit <n>
Sortie vide, fini Affiche (no output)
Sortie vide, en cours N'affiche rien
Plafond de sortie 10000 lignes ; au-delà les plus anciennes partent et une ligne … n earlier lines dropped … le dit
Touche Effet
PgUp PgDn Home End Parcourir la sortie
Molette Idem
Échap, Entrée, Close Le fermer, en arrêtant la commande si elle tourne encore

Fermer arrête la commande parce qu'il n'y a pas d'autre moyen d'interrompre une commande dont la sortie n'est pas dans un terminal.

output = "terminal"

Propriété Valeur
Fenêtre Une fenêtre de terminal à elle, titrée de la commande
Environnement Celui de l'éditeur, avec TERM à xterm-256color
Après sa fin La fenêtre reste, montrant sa sortie
Modal Non : l'éditeur continue à côté

Comme c'est un vrai terminal, les couleurs, la pagination, Ctrl-C et la lecture du clavier marchent tous — les coches vertes de node --test, un script qui lit process.stdin, un serveur qui journalise jusqu'à ce qu'on l'interrompe. Voir Fenêtres de terminal.

Touches dans une fenêtre de terminal terminée :

Touche Effet
Shift-PgUp, Shift-PgDn Remonter dans la sortie
Ctrl-W Fermer la fenêtre
Tout le reste Atteint l'éditeur, pas le shell mort

output = "editor"

Propriété Valeur
Affiche Un popup pendant l'exécution, comme ci-dessus
À la fermeture du popup Une fenêtre d'édition contenant la sortie, titrée de la commande
Remplie Une fois, quand la commande est finie — pas au fil de l'eau
La fenêtre Une fenêtre d'édition ordinaire sans nom de fichier : Ctrl-F la fouille, et Save as la conserve

Rechargement après une commande

Quand une commande se termine, chaque fichier ouvert est considéré.

Le fichier Ce qui se passe
Non modifié, et changé sur le disque Relu ; sa syntaxe est redécidée et son titre rafraîchi
Non modifié, et inchangé sur le disque Laissé tranquille, non compté
Avec des modifications non enregistrées Laissé tranquille et compté comme ignoré
Jamais nommé Laissé tranquille
Disparu du disque Laissé tranquille

Le curseur reste où il était, ramené dans ce que le fichier contient désormais. L'historique d'annulation est jeté, parce qu'annuler au-delà d'un rechargement restaurerait un texte que le fichier n'a plus.

L'arbre du projet est rafraîchi au même instant — c'est ainsi que node_modules/ et package-lock.json, écrits par npm install, y apparaissent.

Barre d'état Quand
Running <commande> La fenêtre s'ouvre
Reloaded 2 files Deux fichiers ont été relus, aucun ignoré
Reloaded 2 files; 1 file with unsaved changes left alone Certains ont été ignorés
Command finished; 1 file with unsaved changes left alone Rien n'a été relu, quelque chose a été ignoré

Erreurs

Message Cause
Cannot read tools dans le menu Le fichier est présent mais n'est pas du TOML valide, ou contient un outil sans nom ou sans commande
Already there: .turbo-js/tools.toml Création dans un projet qui en a déjà un. Inatteignable depuis le menu, qui grise l'entrée ; toujours possible pour un appelant qui n'est pas un menu.
This project has no .turbo-js/tools.toml yet. Ouverture dans un projet qui n'en a pas, de même
Cannot tell which directory this is: … Le répertoire courant n'a pas pu être lu
Terminal windows are not supported on this platform yet Lancer une commande demande un pseudo-terminal, que Linux, macOS et Windows possèdent ; voir Fenêtres de terminal

Demander une valeur

Un {{libellé}} n'importe où dans une commande est une valeur que l'éditeur demande avant de l'exécuter, dans une boîte titrée du nom de l'outil. Le texte entre les accolades est ce que la boîte demande.

Écrit Demandé Substitué
{{script, e.g. main.js}} script, e.g. main.js cité pour le shell
{{arguments...}} arguments tel quel

Une valeur est citée pour le shell par défaut, un chemin avec un espace reste donc un seul argument. Un ... final dans les accolades la demande telle quelle, et c'est ainsi qu'un champ peut valoir plusieurs arguments.

[[tool]]
name = "Run with ~a~rguments"
command = "node main.js {{arguments...}}"
output = "terminal"
Règle Comportement
Plusieurs champs Une boîte, un champ chacun, dans l'ordre d'apparition dans la commande
Le même libellé deux fois Un champ ; chaque occurrence reçoit ce qui y est tapé
Un libellé écrit des deux façons Demandé une fois ; chaque occurrence honore ses propres accolades
Échap, ou Cancel La commande ne s'exécute pas
Un champ laissé vide Substitué par du vide — la commande émet sa propre plainte
Relancer l'outil La boîte part de ce qui a été tapé la fois précédente, pour cette session seulement
Plus de champs qu'il n'en tient à l'écran Refusé, avec un message disant combien tiennent

Doubles accolades, pas simples. awk '{print $1}' et find . -exec rm {} + sont des commandes ordinaires, et une syntaxe à accolades simples lirait la première comme une demande de valeur appelée print $1.

Rien n'est écrit sur le disque. Une valeur que quelqu'un a tapée cet après-midi n'est pas une décision prise par le projet, elle ne va donc pas dans le répertoire propre du projet.

Erreurs

Erreur Cause
tool "X": "{{script" is never closed Un {{ ouvrant sans }} après lui
tool "X": {{}} asks for a value but does not say what it is Un champ sans libellé, ou qui n'est que ...

Les deux sont refusés à la lecture du fichier, un champ à moitié tapé n'atteint donc jamais le shell avec ses accolades.

Voir aussi

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
# Référence : outils JavaScript

> Description neutre de `.turbo-js/tools.toml`, du menu JavaScript, et de ce que fait l'exécution d'une commande.

## Fichier

| Propriété | Valeur |
| --- | --- |
| Chemin | `./.turbo-js/tools.toml` |
| Recherche | Le répertoire courant seulement. Les répertoires parents ne sont **pas** parcourus. |
| Lecture | À chaque ouverture de l'un de ses menus, pour les entrées |
| Relecture | Dès que la taille ou la date de modification du fichier change, pour l'**ensemble** des menus |
| Fichier absent | Pas une erreur |
| Fichier illisible | Une erreur, affichée dans le menu |
| Fichier au niveau utilisateur | **Aucun.** Contrairement aux snippets, il n'y a pas de `~/.config/turbo-js/tools.toml`. |

## Format du fichier

Une table `[[tool]]` par commande.

| Clé | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `name` | chaîne | oui | Ce que le menu affiche. Peut porter une touche chaude entre tildes, comme `"~T~est"`. |
| `command` | chaîne | oui | La commande shell à lancer |
| `output` | chaîne | non | Où va sa sortie : `popup`, `terminal` ou `editor`. Absent signifie `popup`. |
| `menu` | chaîne | non | Dans quel menu elle apparaît. Absent signifie `JavaScript`. N'importe quel nom ; le menu est créé pour vous. Peut porter une touche chaude entre tildes. |

`menu` n'est pas vérifié contre une liste, parce qu'il n'y a pas de liste : un nom qu'aucun autre outil n'utilise crée simplement un menu. Un outil sans `name`, sans `command`, ou dont l'`output` nomme quelque chose qui n'existe pas rend tout le fichier erroné. Un `output` inconnu est **refusé plutôt que corrigé** : `"termnial"` aurait sinon l'air d'avoir marché tout en envoyant la sortie ailleurs.

### Exemple

```toml
[[tool]]
name = "~T~est"
command = "node --test"
output = "popup"

[[tool]]
name = "~E~cho"
command = "echo TADA"
output = "terminal"
menu = "Tools"
```

## Le fichier de départ

**JavaScript ▸ Create tools file** écrit ces sept outils, dans cet ordre :

| Nom | Commande | Sortie | Menu |
| --- | --- | --- | --- |
| `~I~nstall` | `npm install` | `popup` | JavaScript |
| `~F~ormat` | `npx prettier --write .` | `popup` | JavaScript |
| `~L~int` | `npx eslint .` | `popup` | JavaScript |
| `~T~est` | `node --test` | `popup` | JavaScript |
| `~R~un` | `node {{script, e.g. main.js}}` | `terminal` | JavaScript |
| `~S~tart` | `npm start` | `terminal` | JavaScript |
| `~E~cho` | `echo 🎉 tada!` | `terminal` | Tools |

`Install` vient en premier parce que c'est la première chose qu'on lance dans un clone frais, et celle qui doit avoir tourné avant qu'aucune des autres ne puisse. L'un d'eux demande une valeur avant de s'exécuter — `Run`, parce qu'un projet Node n'a pas de point d'entrée unique que l'éditeur pourrait connaître — et un nomme un `menu` à lui. Ces deux fonctionnalités sont invisibles si le fichier de départ ne les montre pas.

`Run` et `Start` reçoivent un terminal : un script peut lire le clavier, et `npm start` est d'habitude un serveur qu'il faut interrompre par `Ctrl-C`. `Format` et `Lint` passent par `npx`, qui lance le Prettier et l'ESLint propres au projet quand `package.json` en dépend et les télécharge dans un cache sinon ; ESLint 9 a besoin d'un `eslint.config.js` dans le projet. `Test` est le lanceur de Node lui-même, qui n'a besoin de rien d'installé : il exécute chaque fichier `*.test.js`, `*.spec.js` et `test/**/*.js` sous le répertoire courant.

Il n'y a pas de `Build`, parce que JavaScript n'a pas d'étape de compilation. `node --check {{script}}` est la vérification de syntaxe qu'ajoute qui en veut une.

Chaque outil nomme son `output`, y compris ceux qui nomment le défaut : la clé est la partie intéressante du format, et un fichier où elle apparaît une fois est un fichier où personne ne remarque qu'elle existe.

L'entrée est grisée une fois que le projet a un fichier d'outils, elle ne peut donc pas en écraser un. Le fichier est écrit via un fichier temporaire dans le même répertoire, renommé en place.

## Le menu JavaScript

Toujours sur la barre, qu'un fichier d'outils existe ou non. Sa touche chaude est `Alt-J`.

| Entrée | Condition |
| --- | --- |
| Une ligne par outil sans `menu`, dans l'ordre du fichier | Le fichier en contient au moins un |
| `Cannot read tools`, grisé | Le fichier est présent mais illisible |
| `Create tools file` | Le projet n'a pas de fichier d'outils |
| `Open tools file` | Le projet en a un |

## Les menus qu'un outil demande

Un `menu` nommant autre chose que `JavaScript` met un menu de ce nom sur la barre.

| Propriété | Valeur |
| --- | --- |
| Position | Entre JavaScript et Help |
| Ordre | L'ordre dans lequel chaque nom apparaît pour la première fois dans le fichier |
| Entrées | Une ligne par outil nommant ce menu, dans l'ordre du fichier. Rien d'autre — `Create tools file` et `Open tools file` restent dans JavaScript. |
| Fichier illisible | Aucun menu du tout ; le menu JavaScript porte l'erreur |
| Pendant que l'éditeur tourne | Ajoutés, retirés et renommés au fil des changements du fichier, sans redémarrage |

### Touches chaudes

Attribuées automatiquement, parce qu'un nom venu d'un fichier ne peut pas être vérifié à l'avance contre les menus fixes.

| Cas | Résultat |
| --- | --- |
| Pas de tilde dans le nom | La première lettre qu'aucun autre menu n'a revendiquée est marquée. `Tools` devient `~T~ools` : `T` est libre. `Format` devient `For~m~at` : `F` est à File, `o` à Options, `r` à Run. |
| Des tildes nommant une lettre libre | Conservés tels quels. `Doc~k~er` répond à `Alt-K`. |
| Des tildes nommant une lettre prise | Abandonnés, et une lettre libre choisie à la place. `~F~oo` devient `F~o~o`. |
| Toutes les lettres prises | Pas de touche chaude. `F10` et la souris l'ouvrent toujours. |

Les lettres que tiennent les menus propres de l'éditeur sont `F`, `E`, `S`, `R`, `C`, `O`, `W`, `N` (Snippets), `A` (Agent), `J` (JavaScript) et `H`.

## Exécuter une commande

Commun à toutes les sorties :

| Propriété | Valeur |
| --- | --- |
| Shell | `/bin/sh -c "<commande>"` sous Linux et macOS ; `cmd.exe /S /C "<commande>"` — le shell que nomme `%COMSPEC%` — sous Windows |
| Répertoire | Le répertoire dans lequel l'éditeur a été lancé |
| Sortie d'erreur | Fusionnée dans la sortie standard, dans l'ordre où la commande les a écrites |

Passer par un shell signifie que les tubes, les globs, `&&` et `;` marchent tous, un outil peut donc être une séquence. Sous Windows le shell est cmd.exe, qui connaît `&&`, `|` et `>` mais ne développe pas les globs, et où `;` n'est pas un séparateur.

### `output = "popup"`

| Propriété | Valeur |
| --- | --- |
| S'ouvre | Immédiatement, avant que la commande soit finie |
| Modal | Oui : rien d'autre dans l'éditeur n'est utilisable pendant qu'il est là |
| Se remplit | À mesure que la sortie arrive, en la suivant jusqu'à ce que vous remontiez |
| Titre pendant l'exécution | `<commande> — running` |
| Titre une fois fini | `<commande> — ok`, ou `<commande> — exit <n>` |
| Sortie vide, fini | Affiche `(no output)` |
| Sortie vide, en cours | N'affiche rien |
| Plafond de sortie | 10000 lignes ; au-delà les plus anciennes partent et une ligne `… n earlier lines dropped …` le dit |

| Touche | Effet |
| --- | --- |
| `↑` `↓` `PgUp` `PgDn` `Home` `End` | Parcourir la sortie |
| Molette | Idem |
| `Échap`, `Entrée`, **Close** | Le fermer, **en arrêtant la commande** si elle tourne encore |

Fermer arrête la commande parce qu'il n'y a pas d'autre moyen d'interrompre une commande dont la sortie n'est pas dans un terminal.

### `output = "terminal"`

| Propriété | Valeur |
| --- | --- |
| Fenêtre | Une fenêtre de terminal à elle, titrée de la commande |
| Environnement | Celui de l'éditeur, avec `TERM` à `xterm-256color` |
| Après sa fin | La fenêtre reste, montrant sa sortie |
| Modal | Non : l'éditeur continue à côté |

Comme c'est un vrai terminal, les couleurs, la pagination, `Ctrl-C` et la lecture du clavier marchent tous — les coches vertes de `node --test`, un script qui lit `process.stdin`, un serveur qui journalise jusqu'à ce qu'on l'interrompe. Voir [Fenêtres de terminal](terminal.md).

Touches dans une fenêtre de terminal **terminée** :

| Touche | Effet |
| --- | --- |
| `Shift-PgUp`, `Shift-PgDn` | Remonter dans la sortie |
| `Ctrl-W` | Fermer la fenêtre |
| Tout le reste | Atteint l'éditeur, pas le shell mort |

### `output = "editor"`

| Propriété | Valeur |
| --- | --- |
| Affiche | Un popup pendant l'exécution, comme ci-dessus |
| À la fermeture du popup | Une fenêtre d'édition contenant la sortie, titrée de la commande |
| Remplie | Une fois, quand la commande est finie — pas au fil de l'eau |
| La fenêtre | Une fenêtre d'édition ordinaire sans nom de fichier : `Ctrl-F` la fouille, et `Save as` la conserve |

## Rechargement après une commande

Quand une commande se termine, chaque fichier ouvert est considéré.

| Le fichier | Ce qui se passe |
| --- | --- |
| Non modifié, et changé sur le disque | Relu ; sa syntaxe est redécidée et son titre rafraîchi |
| Non modifié, et inchangé sur le disque | Laissé tranquille, non compté |
| Avec des modifications non enregistrées | Laissé tranquille et compté comme ignoré |
| Jamais nommé | Laissé tranquille |
| Disparu du disque | Laissé tranquille |

Le curseur reste où il était, ramené dans ce que le fichier contient désormais. L'historique d'annulation est jeté, parce qu'annuler au-delà d'un rechargement restaurerait un texte que le fichier n'a plus.

L'arbre du projet est rafraîchi au même instant — c'est ainsi que `node_modules/` et `package-lock.json`, écrits par `npm install`, y apparaissent.

| Barre d'état | Quand |
| --- | --- |
| `Running <commande>` | La fenêtre s'ouvre |
| `Reloaded 2 files` | Deux fichiers ont été relus, aucun ignoré |
| `Reloaded 2 files; 1 file with unsaved changes left alone` | Certains ont été ignorés |
| `Command finished; 1 file with unsaved changes left alone` | Rien n'a été relu, quelque chose a été ignoré |

## Erreurs

| Message | Cause |
| --- | --- |
| `Cannot read tools` dans le menu | Le fichier est présent mais n'est pas du TOML valide, ou contient un outil sans nom ou sans commande |
| `Already there: .turbo-js/tools.toml` | Création dans un projet qui en a déjà un. Inatteignable depuis le menu, qui grise l'entrée ; toujours possible pour un appelant qui n'est pas un menu. |
| `This project has no .turbo-js/tools.toml yet.` | Ouverture dans un projet qui n'en a pas, de même |
| `Cannot tell which directory this is: …` | Le répertoire courant n'a pas pu être lu |
| `Terminal windows are not supported on this platform yet` | Lancer une commande demande un pseudo-terminal, que Linux, macOS et Windows possèdent ; voir [Fenêtres de terminal](terminal.md) |

## Demander une valeur

Un `{{libellé}}` n'importe où dans une commande est une valeur que l'éditeur demande avant de l'exécuter, dans une boîte titrée du nom de l'outil. Le texte entre les accolades est ce que la boîte demande.

| Écrit | Demandé | Substitué |
| --- | --- | --- |
| `{{script, e.g. main.js}}` | `script, e.g. main.js` | cité pour le shell |
| `{{arguments...}}` | `arguments` | tel quel |

Une valeur est **citée pour le shell** par défaut, un chemin avec un espace reste donc un seul argument. Un `...` final dans les accolades la demande telle quelle, et c'est ainsi qu'un champ peut valoir plusieurs arguments.

```toml
[[tool]]
name = "Run with ~a~rguments"
command = "node main.js {{arguments...}}"
output = "terminal"
```

| Règle | Comportement |
| --- | --- |
| Plusieurs champs | Une boîte, un champ chacun, dans l'ordre d'apparition dans la commande |
| Le même libellé deux fois | Un champ ; chaque occurrence reçoit ce qui y est tapé |
| Un libellé écrit des deux façons | Demandé une fois ; chaque occurrence honore ses propres accolades |
| Échap, ou Cancel | La commande ne s'exécute pas |
| Un champ laissé vide | Substitué par du vide — la commande émet sa propre plainte |
| Relancer l'outil | La boîte part de ce qui a été tapé la fois précédente, pour cette session seulement |
| Plus de champs qu'il n'en tient à l'écran | Refusé, avec un message disant combien tiennent |

**Doubles accolades, pas simples.** `awk '{print $1}'` et `find . -exec rm {} +` sont des commandes ordinaires, et une syntaxe à accolades simples lirait la première comme une demande de valeur appelée `print $1`.

Rien n'est écrit sur le disque. Une valeur que quelqu'un a tapée cet après-midi n'est pas une décision prise par le projet, elle ne va donc pas dans le répertoire propre du projet.

### Erreurs

| Erreur | Cause |
| --- | --- |
| `tool "X": "{{script" is never closed` | Un `{{` ouvrant sans `}}` après lui |
| `tool "X": {{}} asks for a value but does not say what it is` | Un champ sans libellé, ou qui n'est que `...` |

Les deux sont refusés à la lecture du fichier, un champ à moitié tapé n'atteint donc jamais le shell avec ses accolades.

## Voir aussi

- [Lancer des commandes Node depuis l'éditeur](../how-to/run-node-commands.md)
- [Outils JavaScript](../explanation/javascript-tools.md)
- [Fenêtres de terminal](terminal.md)