fbp-language 1.1.9 → 1.2.0

package/assets/fbp-logo.svg

@@ -1,6 +1,6 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 128" role="img" aria-labelledby="title">
-  <title id="title">FBP — { B }</title>
-  <g fill="currentColor" font-family="Arial, Helvetica, sans-serif" font-size="88" font-weight="600" text-anchor="middle">
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 128">
+  <title>FBP file icon</title>
+  <g fill="#718DB5" font-family="Arial, Helvetica, sans-serif" font-size="88" font-weight="600" text-anchor="middle">
     <text x="48" y="94">{</text>
     <text x="128" y="94">B</text>
     <text x="208" y="94">}</text>

package/extension.js

@@ -0,0 +1,167 @@
+const vscode = require("vscode");
+
+const builtins = [
+  ["affiche", "Affiche une ou plusieurs valeurs dans le terminal."],
+  ["ping", "Vérifie que le moteur FBP répond."],
+  ["discordConnexion", "Connecte le bot à Discord."],
+  ["discordCommande", "Déclare une commande slash avec une réponse texte."],
+  ["discordCommandeEmbed", "Déclare une commande slash avec un embed."],
+  ["discordChamp", "Ajoute un champ fixe à un embed."],
+  ["discordChampDynamique", "Ajoute un champ alimenté par une source Discord."],
+  ["discordOptionTexte", "Ajoute une option texte à une commande slash."],
+  ["discordOptionNombre", "Ajoute une option numérique."],
+  ["discordOptionEntier", "Ajoute une option entière."],
+  ["discordOptionBooleen", "Ajoute une option vrai/faux."],
+  ["discordOptionSalon", "Ajoute un sélecteur de salon."],
+  ["discordOptionUtilisateur", "Ajoute un sélecteur de membre à un embed."],
+  ["discordChoixTexte", "Ajoute un choix à une option texte."],
+  ["discordChoixEntier", "Ajoute un choix à une option entière."],
+  ["discordOptionNombreLimites", "Définit les limites d'une option numérique."],
+  ["discordOptionEntierLimites", "Définit les limites d'une option entière."]
+];
+
+const keywords = [
+  ["import", "Importe des fonctions depuis un autre fichier FBP."],
+  ["de", "Introduit le chemin d'un import."],
+  ["true", "Valeur booléenne vraie."],
+  ["false", "Valeur booléenne fausse."]
+];
+
+function provideCompletions(document, position) {
+  const linePrefix = document.lineAt(position).text.slice(0, position.character);
+  const items = [];
+  for (const [name, detail] of builtins) {
+    const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Function);
+    item.detail = "Fonction FBP intégrée";
+    item.documentation = new vscode.MarkdownString(detail);
+    item.insertText = new vscode.SnippetString(name + "($0)");
+    item.sortText = "0-" + name;
+    items.push(item);
+  }
+  for (const [name, detail] of keywords) {
+    const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Keyword);
+    item.detail = "Mot-clé FBP";
+    item.documentation = detail;
+    item.sortText = "1-" + name;
+    items.push(item);
+  }
+
+  const declaredFunctions = /(?:^|\n)\s*([\p{L}_][\p{L}\p{N}_]*)\s*\(\s*\)\s*\{/gu;
+  for (const match of document.getText().matchAll(declaredFunctions)) {
+    const name = match[1];
+    if (builtins.some(([builtin]) => builtin === name)) continue;
+    const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Function);
+    item.detail = "Fonction définie dans ce fichier";
+    item.insertText = new vscode.SnippetString(name + "($0)");
+    items.push(item);
+  }
+
+  const variables = /(?:^|\n)\s*([\p{L}_][\p{L}\p{N}_]*)\s*=\s*[^=]/gu;
+  for (const match of document.getText().matchAll(variables)) {
+    const name = match[1];
+    const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Variable);
+    item.detail = "Variable FBP";
+    item.sortText = "2-" + name;
+    items.push(item);
+  }
+  return items;
+}
+
+function validateDocument(document, collection) {
+  if (document.languageId !== "fbp") return;
+  const diagnostics = [];
+  const lines = document.getText().split(/\r?\n/);
+  const stack = [];
+  const functionNames = new Set();
+  for (const raw of lines) {
+    const match = raw.trim().match(/^([\\p{L}_][\\p{L}\\p{N}_]*)\\s*\\(\\s*\\)\\s*\\{$/u);
+    if (match) functionNames.add(match[1]);
+  }
+  const builtInNames = new Set(builtins.map(([name]) => name));
+  const declaration = /^([\p{L}_][\p{L}\p{N}_]*)\s*\(\s*\)\s*\{$/u;
+  const assignment = /^([\p{L}_][\p{L}\p{N}_]*)\s*=\s*(.+)$/u;
+  const call = /^([\p{L}_][\p{L}\p{N}_]*)\s*\((.*)\)\s*;?$/u;
+  const importLine = /^import\s*\{\s*([^}]+)\s*\}\s*de\s*(["'])(.+?)\2\s*$/u;
+  const identifier = /^[\p{L}_][\p{L}\p{N}_]*$/u;
+
+  function add(lineIndex, text, message, severity = vscode.DiagnosticSeverity.Error) {
+    const start = Math.max(0, lines[lineIndex].indexOf(text));
+    const end = start + Math.max(1, text.length);
+    const diagnostic = new vscode.Diagnostic(
+      new vscode.Range(lineIndex, start, lineIndex, Math.min(lines[lineIndex].length, end)),
+      message,
+      severity
+    );
+    diagnostic.source = "FBP";
+    diagnostics.push(diagnostic);
+  }
+
+  lines.forEach((raw, index) => {
+    const line = raw.trim();
+    if (!line || line.startsWith("//") || line.startsWith("#")) return;
+    if (importLine.test(line)) return;
+
+    const fn = line.match(declaration);
+    if (fn) {
+      if (functionNames.has(fn[1])) add(index, fn[1], "Cette fonction est déjà définie.");
+      functionNames.add(fn[1]);
+      stack.push({ name: fn[1], line: index });
+      return;
+    }
+
+    if (line === "}") {
+      if (!stack.length) add(index, "}", "Accolade fermante sans fonction correspondante.");
+      else stack.pop();
+      return;
+    }
+
+    const assign = line.match(assignment);
+    if (assign) {
+      if (!assign[2].trim()) add(index, assign[1], "Une valeur est attendue après le signe =.");
+      return;
+    }
+
+    const invocation = line.match(call);
+    if (invocation) {
+      if (!builtInNames.has(invocation[1]) && !functionNames.has(invocation[1])) {
+        add(index, invocation[1], "Fonction inconnue ou non déclarée : " + invocation[1] + ".", vscode.DiagnosticSeverity.Warning);
+      }
+      if (invocation[2].trim() && /(^|,)\s*(,|$)/.test(invocation[2])) {
+        add(index, invocation[2], "Argument vide dans l'appel de fonction.");
+      }
+      return;
+    }
+
+    add(index, line, "Syntaxe FBP non reconnue. Vérifie les parenthèses, les accolades et le signe =.");
+  });
+
+  for (const open of stack) {
+    add(open.line, lines[open.line].trim(), "La fonction « " + open.name + " » n'est pas fermée par }.");
+  }
+  collection.set(document.uri, diagnostics);
+}
+
+function activate(context) {
+  const diagnostics = vscode.languages.createDiagnosticCollection("fbp");
+  context.subscriptions.push(diagnostics);
+
+  context.subscriptions.push(
+    vscode.languages.registerCompletionItemProvider(
+      { language: "fbp", scheme: "file" },
+      { provideCompletionItems: provideCompletions },
+      ".", " "
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.workspace.onDidOpenTextDocument(document => validateDocument(document, diagnostics)),
+    vscode.workspace.onDidChangeTextDocument(event => validateDocument(event.document, diagnostics)),
+    vscode.workspace.onDidCloseTextDocument(document => diagnostics.delete(document.uri))
+  );
+
+  for (const document of vscode.workspace.textDocuments) validateDocument(document, diagnostics);
+}
+
+function deactivate() {}
+
+module.exports = { activate, deactivate };

package/language-configuration.json

@@ -18,4 +18,4 @@
     ["\"", "\""],
     ["'", "'"]
   ]
-}
+}

package/package.json

@@ -1,73 +1,22 @@
 {
   "name": "fbp-language",
-  "displayName": "FBP - French Bot Programming",
-  "description": "Langage FBP avec compilateur, commandes Discord et support VS Code.",
-  "version": "1.1.9",
-  "type": "commonjs",
-  "main": "dist/compiler.js",
-  "bin": {
-    "fbp": "dist/cli.js"
-  },
-  "files": [
-    "dist/",
-    "README.md",
-    "syntaxes/",
-    "assets/",
-    "themes/",
-    "vscode-extension/",
-    "language-configuration.json",
-    "package.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/GabyY-1/French-Bot-Programming.git"
-  },
-  "homepage": "https://github.com/GabyY-1/French-Bot-Programming#readme",
-  "bugs": {
-    "url": "https://github.com/GabyY-1/French-Bot-Programming/issues"
-  },
-  "keywords": [
-    "fbp",
-    "language",
-    "interpreter",
-    "french",
-    "cli",
-    "discord",
-    "slash-commands",
-    "bot",
-    "vscode-extension"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepare": "npm run build",
-    "prepublishOnly": "npm test",
-    "start": "node dist/cli.js",
-    "dev": "ts-node src/cli.ts",
-    "test": "npm run build && node --test tests/*.test.cjs"
-  },
+  "displayName": "FBP Language Support",
+  "description": "Coloration syntaxique, autocomplétion, détection des erreurs et thème d'icônes FBP.",
+  "version": "1.2.0",
+  "publisher": "gabyy1",
   "engines": {
-    "node": ">=20"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.7.2"
-  },
-  "dependencies": {
-    "discord.js": "^14.19.3",
-    "dotenv": "^16.4.7"
+    "vscode": "^1.80.0"
   },
+  "main": "./extension.js",
+  "categories": ["Programming Languages", "Themes"],
+  "extensionKind": ["workspace"],
+  "activationEvents": ["onLanguage:fbp"],
   "contributes": {
     "languages": [
       {
         "id": "fbp",
-        "aliases": [
-          "FBP",
-          "fbp"
-        ],
-        "extensions": [
-          ".fbp"
-        ],
+        "aliases": ["FBP", "fbp"],
+        "extensions": [".fbp"],
         "configuration": "./language-configuration.json"
       }
     ],

package/syntaxes/fbp.tmLanguage.json

@@ -2,99 +2,48 @@
   "scopeName": "source.fbp",
   "name": "FBP",
   "patterns": [
-    {
-      "include": "#strings"
-    },
-    {
-      "include": "#numbers"
-    },
-    {
-      "include": "#keywords"
-    },
-    {
-      "include": "#booleans"
-    },
-    {
-      "include": "#function-declarations"
-    },
-    {
-      "include": "#function-calls"
-    },
-    {
-      "include": "#assignments"
-    },
-    {
-      "include": "#operators"
-    },
-    {
-      "include": "#punctuation"
-    }
+    { "include": "#comments" },
+    { "include": "#strings" },
+    { "include": "#numbers" },
+    { "include": "#keywords" },
+    { "include": "#booleans" },
+    { "include": "#function-declarations" },
+    { "include": "#function-calls" },
+    { "include": "#assignments" },
+    { "include": "#operators" },
+    { "include": "#punctuation" }
   ],
   "repository": {
+    "comments": {
+      "patterns": [
+        { "name": "comment.line.double-slash.fbp", "match": "//.*$" },
+        { "name": "comment.line.number-sign.fbp", "match": "#.*$" }
+      ]
+    },
     "strings": {
       "name": "string.quoted.double.fbp",
       "begin": "\"",
-      "beginCaptures": {
-        "0": {
-          "name": "punctuation.definition.string.begin.fbp"
-        }
-      },
+      "beginCaptures": { "0": { "name": "punctuation.definition.string.begin.fbp" } },
       "end": "\"",
-      "endCaptures": {
-        "0": {
-          "name": "punctuation.definition.string.end.fbp"
-        }
-      },
-      "patterns": [
-        {
-          "name": "constant.character.escape.fbp",
-          "match": "\\\\."
-        }
-      ]
-    },
-    "numbers": {
-      "name": "constant.numeric.fbp",
-      "match": "\\b\\d+(?:\\.\\d+)?\\b"
-    },
-    "keywords": {
-      "name": "keyword.control.fbp",
-      "match": "\\b(?:import|de)\\b"
-    },
-    "booleans": {
-      "name": "constant.language.boolean.fbp",
-      "match": "\\b(?:true|false)\\b"
+      "endCaptures": { "0": { "name": "punctuation.definition.string.end.fbp" } },
+      "patterns": [{ "name": "constant.character.escape.fbp", "match": "\\\\." }]
     },
+    "numbers": { "name": "constant.numeric.fbp", "match": "\\b\\d+(?:\\.\\d+)?\\b" },
+    "keywords": { "name": "keyword.control.fbp", "match": "\\b(?:import|de)\\b" },
+    "booleans": { "name": "constant.language.boolean.fbp", "match": "\\b(?:true|false)\\b" },
     "function-declarations": {
       "match": "\\b([\\p{L}_][\\p{L}\\p{N}_]*)\\s*(?=\\(\\s*\\)\\s*\\{)",
-      "captures": {
-        "1": {
-          "name": "entity.name.function.fbp"
-        }
-      }
+      "captures": { "1": { "name": "entity.name.function.fbp" } }
     },
     "function-calls": {
       "match": "\\b([\\p{L}_][\\p{L}\\p{N}_]*)\\s*(?=\\()",
-      "captures": {
-        "1": {
-          "name": "support.function.fbp"
-        }
-      }
+      "captures": { "1": { "name": "support.function.fbp" } }
     },
     "assignments": {
       "match": "\\b([\\p{L}_][\\p{L}\\p{N}_]*)\\s*(?==)",
-      "captures": {
-        "1": {
-          "name": "variable.other.assignment.fbp"
-        }
-      }
-    },
-    "operators": {
-      "name": "keyword.operator.fbp",
-      "match": "(?:=|\\+|\\-|\\*|/|==|!=|<=|>=)"
+      "captures": { "1": { "name": "variable.other.assignment.fbp" } }
     },
-    "punctuation": {
-      "name": "punctuation.section.fbp",
-      "match": "[{}()\\[\\],.]"
-    }
+    "operators": { "name": "keyword.operator.fbp", "match": "(?:=|\\+|\\-|\\*|/|==|!=|<=|>=)" },
+    "punctuation": { "name": "punctuation.section.fbp", "match": "[{}()\\[\\],.]" }
   }
-}
+}

package/themes/fbp-icon-theme.json

@@ -2,7 +2,7 @@
   "$schema": "vscode://schemas/icon-theme",
   "iconDefinitions": {
     "_fbp": {
-      "iconPath": "../assets/fbp-logo.svg"
+      "iconPath": "../assets/fbp-logo.png"
     }
   },
   "fileExtensions": {

package/README.md

@@ -1,253 +0,0 @@
-# FBP — French Bot Programming
-
-FBP est un langage interprété par Node.js. Les fichiers source utilisent l'extension `.fbp`. Le paquet fournit le moteur et la commande `fbp`.
-
-## Prérequis
-
-- Node.js 20 ou plus récent
-- npm
-
-## Installation depuis npm
-
-Quand le paquet sera publié sur npm :
-
-```bash
-npm install fbp-language
-```
-
-Puis, dans le `package.json` de ton projet :
-
-```json
-{
-  "scripts": {
-    "start": "fbp run lancer"
-  },
-  "dependencies": {
-    "fbp-language": "^1.1.9"
-  }
-}
-```
-
-Lance le script avec `npm start`. npm rend la commande `fbp` disponible dans les scripts du projet.
-
-## Créer un projet FBP
-
-Crée un fichier `commandes.fbp` à la racine de ton projet. Malgré son extension, ce fichier est actuellement du JSON :
-
-```json
-{
-  "lancer": "scripts/main.fbp"
-}
-```
-
-Crée ensuite le fichier `scripts/main.fbp` :
-
-```fbp
-nom = "Mon projet"
-
-lance() {
-  affiche("FBP fonctionne !")
-  affiche("Projet :", nom)
-}
-
-lance()
-```
-
-Les chemins déclarés dans `commandes.fbp` sont relatifs à la racine du projet.
-
-## Initialiser un projet et installer le support VS Code
-
-Dans le dossier de ton projet, exécute :
-
-```bash
-fbp -init
-```
-
-La commande crée `commandes.fbp` et `scripts/main.fbp` sans écraser les fichiers existants. Elle installe également le support FBP fourni avec le package dans le dossier des extensions VS Code de l’utilisateur. Si tu utilises une instance distante ou un environnement sans dossier d’extensions accessible, l’installation peut nécessiter une configuration manuelle. Recharge ensuite VS Code. Pour l’icône FBP, sélectionne `FBP File Icons` dans **Préférences : Thème d’icônes de fichiers**.
-
-Le support VS Code contient la reconnaissance des fichiers `.fbp`, la coloration syntaxique et le thème d’icônes. Il est livré dans le même dépôt et le même package npm ; aucune extension séparée à rechercher n’est nécessaire.
-
-## Commandes CLI
-
-```bash
-fbp help
-fbp version
-fbp info
-fbp ping
-fbp -init
-fbp run lancer
-fbp run-file scripts/main.fbp
-```
-
-- `fbp run <nom>` exécute la commande correspondante dans le fichier `commandes.fbp` du dossier courant.
-- `fbp run-file <fichier>` exécute directement un fichier FBP.
-- `fbp ping` vérifie que le CLI répond ; il ne se connecte pas à Discord.
-
-## Syntaxe actuelle
-
-```fbp
-nom = "Gab"
-niveau = 15
-actif = true
-
-lance() {
-  affiche("Bonjour", nom)
-}
-
-lance()
-```
-
-- Types reconnus : texte, nombre et booléen.
-- Les fonctions ne prennent pas encore de paramètres.
-- `affiche(...)` écrit dans le terminal.
-- `import { fonction } de "./fichier.fbp"` importe des fonctions.
-- Les commentaires commencent par `//` ou `#`.
-
-## Créer un bot Discord
-
-Installe FBP dans le projet du bot, puis crée un fichier `.env` à la racine :
-
-```env
-DISCORD_TOKEN=ton_token_discord
-```
-
-Ne partage jamais ce fichier et ajoute `.env` à `.gitignore`.
-
-Dans `scripts/main.fbp` :
-
-```fbp
-discordConnexion()
-discordCommande("ping", "Pong !")
-discordCommande("bonjour", "Salut !")
-discordCommandeEmbed("serveur-info", "Informations du serveur", "Voici les informations disponibles.", "#5865F2")
-discordChamp("serveur-info", "Nom", "Mon serveur")
-discordChamp("serveur-info", "Membres", "42")
-```
-
-Associe `lancer` à `scripts/main.fbp` dans `commandes.fbp`, puis exécute `npx fbp run lancer`. Dans le portail développeur Discord, vérifie que le bot est invité sur ton serveur avec les scopes `bot` et `applications.commands`. Seul l'intent serveur (`Guilds`) est nécessaire.
-
-FBP enregistre les commandes déclarées comme commandes slash globales de l'application Discord. Leur apparition peut prendre un peu de temps après le premier enregistrement. Les noms doivent contenir de 1 à 32 caractères parmi les lettres minuscules, chiffres, tirets et underscores.
-
-## Sélecteur de salon Discord (v1.1.8)
-
-Une commande slash peut proposer un sélecteur de salon Discord. La valeur choisie est réutilisable dans la réponse avec `{{salon}}` :
-
-```fbp
-discordConnexion()
-discordCommande("configurer", "Salon sélectionné : {{salon}}")
-discordOptionSalon("configurer", "salon", "Choisis un salon", true)
-```
-
-Le dernier argument indique si l'option est obligatoire. La réponse affiche le nom du salon précédé de `#`. Cette option peut être ajoutée aux commandes texte ou aux commandes embed, comme les autres options slash.
-
-## Limites actuelles
-
-FBP est encore un interpréteur de base. Les paramètres de fonction, les conditions, les boucles, les valeurs de retour et les expressions arithmétiques ne sont pas encore implémentés. La connexion Discord utilise un token stocké dans `.env`. Les commandes slash peuvent répondre avec un texte fixe ou un embed défini avec `discordCommandeEmbed(nom, titre, description, couleur)`. Ajoute des champs avec `discordChamp(nomCommande, nomChamp, valeur)`. Les valeurs des embeds sont actuellement fixes : la récupération dynamique des informations du serveur, les options, paramètres, permissions avancées et conditions ne sont pas encore implémentés.
-
-## Développement du dépôt
-
-```bash
-npm install
-npm test
-```
-
-Les fichiers d'essai internes se trouvent dans `tests/fixtures`. Ils ne font pas partie du paquet publié.
-
-
-## Informations Discord dynamiques (v1.1.6)
-
-Les champs d'un embed peuvent récupérer les informations accessibles au moment où la commande est utilisée. Exemple :
-
-```fbp
-discordConnexion()
-discordCommandeEmbed("serveur-info", "Informations du serveur", "Données actuelles", "#5865F2")
-discordChampDynamique("serveur-info", "Nom", "discordServeur.nom")
-discordChampDynamique("serveur-info", "Identifiant", "discordServeur.id")
-discordChampDynamique("serveur-info", "Création", "discordServeur.creation")
-discordChampDynamique("serveur-info", "Membres", "discordMembres.nombre")
-discordChampDynamique("serveur-info", "Rôles", "discordRoles.nombre")
-discordChampDynamique("serveur-info", "Salons", "discordSalons.nombre")
-discordChampDynamique("serveur-info", "Latence", "discordLatence")
-discordOptionUtilisateur("serveur-info", "membre", "Membre à afficher")
-discordChampDynamique("serveur-info", "Profil", "discordProfil.nom")
-discordChampDynamique("serveur-info", "Avatar", "discordAvatar")
-```
-
-Sources disponibles : `discordServeur.nom`, `discordServeur.id`, `discordServeur.creation`, `discordMembres.nombre`, `discordProfil.nom`, `discordProfil.id`, `discordProfil.avatar`, `discordRoles.nombre`, `discordSalons.nombre`, `discordStatistiques.membres`, `discordStatistiques.roles`, `discordStatistiques.salons`, `discordLatence` et `discordAvatar`. `discordOptionUtilisateur(nomCommande, nomOption, description)` ajoute un sélecteur facultatif de membre à une commande embed. Les données accessibles dépendent des permissions et du cache Discord du bot.
-
-
-## Options des commandes slash (v1.1.6)
-
-Les commandes slash peuvent maintenant recevoir des options texte, nombre, entier ou booléen. Le dernier argument indique si l'option est obligatoire ; il est facultatif et vaut `false` par défaut.
-
-```fbp
-discordConnexion()
-discordCommande("bonjour", "Salut {{prenom}} !")
-discordOptionTexte("bonjour", "prenom", "Ton prénom", true)
-discordOptionEntier("bonjour", "age", "Ton âge")
-discordOptionNombre("bonjour", "note", "Une valeur décimale")
-discordOptionBooleen("bonjour", "confirme", "Confirmer ?")
-```
-
-Dans une réponse texte, `{{prenom}}` est remplacé par la valeur saisie. Pour les embeds, les champs dynamiques peuvent lire une option avec `discordChampDynamique("commande", "Champ", "option.prenom")` (ou `discordOption.prenom`). Les options absentes ne sont pas remplacées et une option obligatoire inaccessible produit une réponse d'erreur.
-
-Fonctions disponibles :
-
-- `discordOptionTexte(commande, nom, description, obligatoire)`
-- `discordOptionNombre(commande, nom, description, obligatoire)`
-- `discordOptionEntier(commande, nom, description, obligatoire)`
-- `discordOptionBooleen(commande, nom, description, obligatoire)`
-- `discordOptionUtilisateur(commande, nom, description)` pour le sélecteur de membre existant des commandes embed.
-
-Les noms d'options doivent respecter les règles Discord (minuscules, chiffres, tirets et underscores, 1 à 32 caractères). Une commande peut avoir jusqu'à 25 options. Les types d'options sont déclarés lors de l'enregistrement des commandes ; redémarre le bot après avoir modifié leur définition. Le bot a besoin du scope `applications.commands` et de l'accès au serveur concerné. Aucun intent privilégié supplémentaire n'est requis pour ces options.
-
-
-## Choix prédéfinis des options (v1.1.6)
-
-Pour limiter les réponses possibles d'une option, ajoute des choix après avoir déclaré l'option :
-
-```fbp
-discordConnexion()
-discordCommande("couleur", "Couleur choisie : {{couleur}}")
-discordOptionTexte("couleur", "couleur", "Choisis une couleur", true)
-discordChoixTexte("couleur", "couleur", "Bleu", "bleu")
-discordChoixTexte("couleur", "couleur", "Rouge", "rouge")
-
-discordCommande("difficulte", "Niveau choisi : {{niveau}}")
-discordOptionEntier("difficulte", "niveau", "Choisis un niveau", true)
-discordChoixEntier("difficulte", "niveau", "Facile", 1)
-discordChoixEntier("difficulte", "niveau", "Normal", 2)
-discordChoixEntier("difficulte", "niveau", "Difficile", 3)
-```
-
-- `discordChoixTexte(commande, option, nomChoix, valeur)` ajoute un choix à une option texte.
-- `discordChoixEntier(commande, option, nomChoix, valeur)` ajoute un choix à une option entière.
-- Déclare toujours l'option avant ses choix.
-- Une option peut avoir jusqu'à 25 choix. Les noms de choix sont limités à 100 caractères.
-- Les choix sont présentés par Discord sous forme de liste et la valeur choisie est récupérable comme les autres options.
-
-
-## Limites numériques des options (v1.1.7)
-
-Les options slash de type nombre et entier peuvent imposer une valeur minimale et maximale. Déclare l'option d'abord, puis ses limites :
-
-```fbp
-discordConnexion()
-discordCommande("age", "Âge sélectionné : {{age}}")
-discordOptionEntier("age", "age", "Choisis un âge", true)
-discordOptionEntierLimites("age", "age", 13, 99)
-
-discordCommande("note", "Note sélectionnée : {{note}}")
-discordOptionNombre("note", "note", "Choisis une note", true)
-discordOptionNombreLimites("note", "note", 0, 20)
-```
-
-- `discordOptionEntierLimites(commande, option, minimum, maximum)` accepte uniquement des bornes entières.
-- `discordOptionNombreLimites(commande, option, minimum, maximum)` accepte des bornes numériques, y compris décimales.
-- Le minimum doit être inférieur ou égal au maximum.
-- Les limites s'appliquent à l'interface Discord. Une option avec des choix prédéfinis ne peut pas recevoir de limites.
-
-
-## Support VS Code
-
-Le dossier `vscode-extension/` contient le manifeste d’extension, la grammaire TextMate, la configuration de langage et le thème d’icônes FBP. La commande `fbp -init` copie ce support dans le dossier d’extensions de VS Code. Le logo du thème d’icônes se trouve dans `vscode-extension/assets/fbp-logo.svg`.