Le principe fondateur de YALT est le suivant : « Écrivons nos interfaces en anglais par défaut et occupons-nous séparément de la localisation. » YALT est un bloc de code qu'il suffit d'insérer au tout début de votre script. Il propose un espace réservé et une syntaxe spécifique permettant de définir des traductions pour chacune des chaînes-clés que vous aurez insérées, en anglais, dans le code client. Vous pourrez ajouter autant de langues que nécessaire. YALT s'occupe de retourner la bonne traduction en fonction de la locale InDesign qu'il détecte automatiquement à l'exécution. Si une chaîne-clé n'est pas traduite vers la langue cible, ou si la langue cible n'est pas supportée dans votre table de traduction, YALT conserve par défaut le texte dans sa forme initiale. Voilà pour le schéma général.

Pour utiliser cette technologie, deux conditions seulement :

• Votre table de traduction sera intégralement transcrite, dans l'espace réservé du bloc YALT, sous forme de commentaires JavaScript ligne par ligne (voir syntaxe ci-dessous).

• Dans votre code, chaque chaîne-clé sera placée entre parenthèses précédées de deux caractères de soulignement, comme ceci :
__("Good morning!").

Voyons un aperçu de cette architecture :

// LE BLOC YALT
//###################################
var L10N = L10N||(function(ln)
{
//============================
// <L10N> :: FRENCH_LOCALE :: GERMAN_LOCALE
//============================
// Good morning! :: Bonjour ! :: Guten Morgen!
// Update :: Actualiser :: Aktualisieren
// Cancel :: Annuler :: Abbrechen
// </L10N>
 
/*
Ici se trouve le code
complet de YALT
*/
})();
 
 
// LE CODE CLIENT
//###################################
alert( __("Good morning!") );
var str = __("Update");
//etc.
 

Mes perspicaces lecteurs auront remarqué que la structure de YALT 2 diffère légèrement de la version inaugurale. Désormais, vous devez placer la table de traduction dans le corps de l'objet L10N. Cette petite modification est innocemment cruciale, car le script récupère à présent les lignes de traduction via la méthode toString() de la fonction englobante, alors qu'initialement YALT était conduit à ouvrir et à lire le contenu du fichier constituant le script lui-même ! Comme vous pouvez l'imaginer, le gain est sensible en termes de performances — et au passage cela met en lumière un point intéressant pour les développeurs : lorsque vous invoquez arguments.callee.toString() dans le corps d'une fonction, vous obtenez en clair le code de la fonction elle-même, commentaires inclus.

Syntaxe

Le format interne de la table de traduction ne diffère pas des versions précédentes. Respectez tout d'abord la syntaxe de la ligne d'en-tête :

// <L10N> :: FRENCH_LOCALE :: GERMAN_LOCALE :: etc.
 

laquelle déclare toutes les langues supportées par votre script. Utilisez la forme exacte, en majuscules, de chaque identifiant XXX_LOCALE tel qu'il est donné par l'énumérateur Locale du DOM InDesign.

Le séparateur de champs reste ' :: ' (espace deux-points deux-points espace). Vous pourriez éventuellement en changer en attaquant la variable SP déclarée dans YALT — sachant que je vous déconseille de bidouiller le reste du code si vous n'êtes pas familier des closures JavaScript.

Enfin, écrivez chaque jeu de traductions sur une seule ligne (aussi longue soit-elle). Le premier champ doit comporter la clé anglaise, tandis que les champs suivants contiennent respectivement la chaîne traduite dans chaque langue déclarée en en-tête, dans le même ordre. N'oubliez pas de démarrer chaque ligne par '// ' (slash slash espace) et de distinguer les chaînes localisées par le séparateur ' :: '.

. . .
// Good morning! :: Bonjour ! :: Guten Morgen!
// Update :: Actualiser :: Aktualisieren
. . .
 

Fonctionnalités avancées

Passage de paramètres. — Une des nouveautés importantes de YALT 2.1 est qu'il autorise désormais l'injection de paramètres dans les chaînes localisées, en utilisant les traditionnels %1, %2... comme marqueurs. Un exemple vaut mieux qu'un long discours :

// Dans la table de traduction
//---------------------------------------
// Good morning %1! :: Bonjour %1 !
// unavailable :: indisponible
// corrupted :: corrompu
// The file %1 is %2! :: Le fichier %1 est %2 !
...
 
// Exemple d'utilisation dans le code client
//---------------------------------------
var userName = "Marc";
alert(  __("Good morning %1!", userName)  );
 
var fName = "test.indd";
var fStatus = __("corrupted");
var msg = __("The file %1 is %2!", fName, fStatus);
 
//etc.
 

Syntaxe « Ascii pur ». — Si comme moi vous souhaitez gardez votre script « 100 % Ascii » pour conjurer les éternelles défaillances de ré-encodage de caractères lors de la circulation du fichier d'une plateforme à une autre, il vous suffit d'utiliser dans vos champs localisés la syntaxe \uHHHH . YALT sait comment s'en dépatouiller :

// Checksum :: Somme de contr\u00F4le :: Pr\u00FCfziffer
 

Il va de soi que HHHH représente le rang Unicode hexadécimal (à toujours composer sur 4 chiffres) du caractère désiré.

Tester une locale en particulier. — Sachant que YALT autodétecte à l'exécution la locale d'InDesign et l'utilise pour traduire automatiquement les chaînes-clés vers la langue correspondante, vous aurez probablement besoin pendant le développement du script de forcer une locale particulière afin de tester les différents contextes d'utilisation. Pour contourner l'autodétection, passez sous forme de String la locale désirée dans la dernière parenthèse du bloc YALT :

. . .
Le bloc YALT
. . .
})('RUSSIAN_LOCALE'); // test de l'interface en russe
 

N'oubliez pas supprimer l'argument en fin de tests. Dans le code d'usine, les parenthèses finales contiennent le commentaire /*'ENGLISH_LOCALE'*/ — ce qui signifie qu'aucun n'argument ne sera transmis. Notez au passage que YALT renvoie un objet JavaScript, L10N, que l'on peut interroger dans le code client pour connaître la localisation effective dans le contexte d'exécution : L10N.locale fournit la locale InDesign sous la forme d'une chaîne lisible : "GERMAN_LOCALE", "ENGLISH_LOCALE", etc.

Comment utiliser YALT dans un jsxbin. — Soulignons tout d'abord que la procédure d'extraction de YALT ne fonctionnera plus, en soi, dans un script compilé (Binary JavaScript), pour la bonne raison que dans ce mode aucune fonction ne peut lire son propre code. Par conséquent, si vous déployez votre script en jsxbin, vous devez en quelque sorte compiler la table de traduction vers un objet JavaScript homologué. Voici comment procéder :

1. Sauvegardez le code source dans un fichier séparé — histoire de garder au chaud la version de travail !
2. Ouvrez le script dans votre éditeur habituel et recherchez la ligne :
   //prompt( "YALT-to-JSXBIN Helper",'var lines='+lines.toSource()+';' );.
3. Décommentez la ligne en supprimant les deux // initiaux.
4. Lancez le script depuis InDesign et copiez dans le presse-papier le contenu qui s'affiche.
5. De retour dans le code, supprimez l'instruction prompt... et remplacer (entièrement) la ligne qui se trouve juste au-dessus par le contenu du presse-papier : var lines=...
6. Vous pouvez également supprimer la table de traduction originelle, c'est-à-dire toutes les lignes mises en commentaires.
7. Assurez-vous que le script fonctionne encore dans cet état (et qu'il affiche correctement le texte localisé).
8. Enfin, depuis l'ExtendScript ToolKit, exportez le script vers le format jsxbin.