Aller au contenu
Vérifié

JavaScript

Du vrai code JS, compilé à l'enregistrement, pour la logique qu'un programme déclaratif ne peut pas exprimer.

Un programme JavaScript contient du vrai code source dans scriptData.value : la porte de sortie pour la logique qu'un programme déclaratif Obtenir des données, Définir des données ou Lot ne peut pas exprimer. Il se compile à l'enregistrement (save_prog exécute la même compilation que Studio et renvoie data.compile, { ok: true, dependencies } ou { ok: false, error }), et il s'exécute avec une vraie API pour les champs, les tables et les événements, pas seulement un élément DOM.

Propriétés

Le contrat d'exécution

Le source est un simple corps asynchrone, sans export, sans enveloppe, exécuté ainsi :

js
async function (params, xu, SESSION_ID, SESSION_OBJ, jobNoP, $container, func, glb, APP_OBJ, evt) {
  /* your source */
}

params sont les paramètres déjà évalués de l'appelant. xu est l'API du runtime : champs, lignes de base de données, événements, HTTP. await fonctionne librement puisque l'enveloppe est asynchrone. Les guillemets sont acceptés ici, contrairement à une valeur d'attribut xu-script.

Lire et écrire une table

js
const raw = await xu.get_field_value(`rows_json_v`);
const rows = typeof raw === `string` ? JSON.parse(raw || `[]`) : raw || [];
for (const row of rows) {
  await xu.dbs_create(`392_tbl_…`, { CNT_Name: row.name || `` });
}
// dbs_read resolves to an ARRAY of { id, value } rows, the row id on .id, fields under .value.
const all = await xu.dbs_read(`392_tbl_…`, {}, [], null, 999);
await xu.set_field_value(`saved_rows_v`, all.map((r) => ({ row_id: r.id, name: r.value?.CNT_Name || `` })));

Les méthodes dbs_* prennent le _id de la table, jamais son nom. La projection fields de dbs_read est facultative : [], la valeur par défaut, renvoie tous les champs, et une liste d'ids de champs ne renvoie que ceux-là.

Transmettre des données : des champs, pas des paramètres

call_native_javascript n'évalue pas les enveloppes de paramètres {value, fx} : un script appelé ainsi reçoit les objets littéraux {value: "", fx: "@field"}, pas des valeurs résolues. Le schéma fiable : l'appelant place d'abord les données dans un champ (une étape update ou une saisie xu-bind), appelle le script avec parameters: {} vide, et le script lit avec xu.get_field_value et rend compte avec xu.set_field_value. Appeler depuis un autre script est différent : les paramètres de xu.call_javascript(prog_id, {...}) arrivent tels que passés.

Invoquer un programme JavaScript

Exemple concret

Déclarez les paramètres

Les entrées progFields deviennent les noms des arguments de la fonction enveloppe, dans l'ordre d'appel.

Écrivez le corps

Un simple corps de fonction asynchrone, avec return d'une valeur si call_evaluate_javascript doit la lire.

Appelez-le et lisez compile.ok

Après save_prog, vérifiez data.compile.ok : une compilation en échec enregistre quand même le document avec un build_error attaché.

Créez un nœud JavaScript sous Programmes, écrivez le source dans l'éditeur de code, ajoutez des paramètres dans la grille Champs. L'enregistrement recompile automatiquement, les erreurs s'affichent dans l'éditeur.

xml
<meta lang="json5">
{
  id: "normalize_student_name",
  menuTitle: "Normalize Student Name"
}
</meta>

<params lang="json5">
{
  in: { raw_name_in: "string" },
  out: { normalized_name_out: "string" }
}
</params>

<code>
return (@raw_name_in || "")
  .trim()
  .split(/\s+/)
  .filter(Boolean)
  .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
  .join(" ");
</code>
json
{
  "properties": { "menuType": "javascript", "menuName": "Slugify Name", "fileExtension": "js" },
  "scriptData": { "value": "return name.toLowerCase().replace(/[^a-z0-9]+/g, '-');", "dependencies": [] },
  "progFields": [
    { "id": "b2c3d4e5-…", "data": { "field_id": "name", "type": "virtual" }, "props": { "fieldType": "string" } }
  ]
}