Lorsque vous travaillez sur un document Adobe InDesign contenant de nombreuses pages, styles et blocs de texte, identifier toutes les polices utilisées peut rapidement devenir fastidieux.

Cette information est pourtant utile dans plusieurs situations :

• préparer un document pour l’impression ;
• transmettre un projet à un autre graphiste ;
• vérifier les polices avant de créer un package InDesign ;
• repérer des polices manquantes ;
• documenter les ressources typographiques d’un projet ;
• effectuer un audit graphique d’une publication.

Adobe InDesign permet déjà de consulter les polices utilisées dans un document, notamment avec la fonction Rechercher une police. Mais lorsqu’on souhaite récupérer ces informations sous forme de fichier exploitable dans Excel, LibreOffice Calc ou Google Sheets, un petit script peut être beaucoup plus pratique.

Nous allons donc créer un script JSX capable d’analyser le document InDesign ouvert et d’exporter les polices utilisées dans un fichier CSV.

Qu’est-ce qu’un script JSX dans InDesign ?

Un fichier .jsx est un fichier JavaScript destiné à l’environnement de script des applications Adobe.

Dans InDesign, les scripts permettent d’automatiser de nombreuses opérations :

• créer des blocs ;
• modifier des styles ;
• analyser du texte ;
• exporter des données ;
• renommer des éléments ;
• générer automatiquement des documents ;
• effectuer des contrôles avant impression.

Le langage utilisé historiquement par InDesign pour ces scripts est basé sur ExtendScript, une implémentation de JavaScript adaptée aux applications Adobe.

Dans notre cas, le script va parcourir le texte du document et récupérer trois informations pour chaque police rencontrée :

1. la famille de caractères ;
2. le style typographique ;
3. le nom PostScript.

Par exemple :

Le nom PostScript est le nom technique de la police utilisé par certains logiciels, systèmes d’impression et workflows de production.

Étape 1 — Ouvrir le panneau Scripts d’InDesign

Commencez par ouvrir le document InDesign que vous souhaitez analyser.

Dans InDesign, ouvrez ensuite :

Fenêtre → Utilitaires → Scripts

Dans une interface anglaise :

Window → Utilities → Scripts

Le panneau affiche généralement plusieurs catégories de scripts.

Nous allons travailler dans le dossier User, c’est-à-dire le dossier contenant vos scripts personnels.

Étape 2 — Localiser le dossier des scripts

La procédure est pratiquement identique sur macOS et Windows.

Sur macOS

Dans le panneau Scripts :

1. repérez le dossier User ;
2. effectuez un clic droit dessus ;
3. choisissez Reveal in Finder ou son équivalent dans votre version française d’InDesign.

Le Finder s’ouvre directement dans le dossier correspondant.

Vous pourrez y placer votre fichier .jsx.

Sur Windows

Dans le panneau Scripts :

1. repérez le dossier User ;
2. effectuez un clic droit ;
3. choisissez Reveal in Explorer ou son équivalent français.

L’Explorateur de fichiers Windows s’ouvre dans le dossier des scripts utilisateur d’InDesign.

L’intérêt de cette méthode est qu’il n’est pas nécessaire de rechercher manuellement le dossier dans les fichiers système.

Étape 3 — Créer le fichier ExportFonts.jsx

Dans le dossier qui vient de s’ouvrir, créez un nouveau fichier appelé :

ExportFonts.jsx

Attention à l’extension du fichier.

Le fichier doit réellement se terminer par :

.jsx

et non :

ExportFonts.jsx.txt

Ce problème est particulièrement fréquent sous Windows lorsque les extensions de fichiers sont masquées.

Créer le fichier sur macOS

Vous pouvez utiliser un éditeur comme :

• Visual Studio Code ;
• Sublime Text ;
• BBEdit ;
• CotEditor ;
• un autre éditeur de texte brut.

Évitez les traitements de texte comme Microsoft Word ou Apple Pages, car ils ajoutent des informations de mise en forme qui ne conviennent pas à un fichier JavaScript.

Créer le fichier sous Windows

Vous pouvez utiliser :

• Visual Studio Code ;
• Notepad++ ;
• Sublime Text ;
• le Bloc-notes ;
• n’importe quel éditeur de texte brut.

Si vous utilisez le Bloc-notes, lors de l’enregistrement, choisissez si nécessaire Tous les fichiers comme type de fichier afin d’éviter que Windows ajoute automatiquement l’extension .txt.

Le nom doit rester exactement :

ExportFonts.jsx

Étape 4 — Ajouter le script

Copiez le script suivant dans votre fichier.

// ================================================================
// Adobe InDesign
// Export de toutes les polices réellement utilisées dans le document
// vers un fichier CSV.
//
// Le script récupère :
// - la famille de la police ;
// - le style de la police ;
// - le nom PostScript.
//
// Le fichier CSV peut ensuite être ouvert dans Excel,
// LibreOffice Calc, Numbers ou Google Sheets.
// ================================================================


// ---------------------------------------------------------------
// 1. Vérifier qu'un document InDesign est ouvert
// ---------------------------------------------------------------

// app.documents représente la collection des documents
// actuellement ouverts dans InDesign.
//
// Si sa longueur est égale à zéro, aucun document n'est ouvert.
if (app.documents.length === 0) {

    // Affiche un message à l'utilisateur.
    alert("Aucun document InDesign n'est ouvert.");

    // Interrompt immédiatement l'exécution du script.
    exit();
}


// ---------------------------------------------------------------
// 2. Récupérer le document actif
// ---------------------------------------------------------------

// app.activeDocument correspond au document actuellement sélectionné.
var doc = app.activeDocument;


// ---------------------------------------------------------------
// 3. Créer un objet destiné à mémoriser les polices
// ---------------------------------------------------------------

// Cet objet va servir de dictionnaire.
//
// Chaque police rencontrée sera enregistrée une seule fois,
// même si elle apparaît plusieurs centaines de fois dans le document.
var fonts = {};


// ---------------------------------------------------------------
// 4. Récupérer toutes les stories du document
// ---------------------------------------------------------------

// Une "story" InDesign représente un flux de texte.
//
// Un même flux peut traverser plusieurs blocs de texte chaînés.
//
// getElements() transforme la collection InDesign
// en éléments que nous pouvons parcourir avec une boucle.
var stories = doc.stories.everyItem().getElements();


// ---------------------------------------------------------------
// 5. Parcourir toutes les stories
// ---------------------------------------------------------------

for (var i = 0; i < stories.length; i++) {

    // textContainers contient les blocs qui accueillent
    // le texte de cette story.
    var textFrames = stories[i].textContainers;


    // -----------------------------------------------------------
    // 6. Parcourir les blocs de texte
    // -----------------------------------------------------------

    for (var j = 0; j < textFrames.length; j++) {

        // Récupération du contenu textuel du bloc.
        var text = textFrames[j].texts[0];


        // -------------------------------------------------------
        // 7. Analyser chaque caractère
        // -------------------------------------------------------

        // Nous examinons chaque caractère afin d'identifier
        // précisément la police réellement appliquée au texte.
        for (var k = 0; k < text.characters.length; k++) {

            try {

                // Récupération de la police appliquée
                // au caractère courant.
                var font = text.characters[k].appliedFont;


                // ---------------------------------------------------
                // 8. Construire une clé unique
                // ---------------------------------------------------

                // Une même famille peut exister dans plusieurs styles.
                //
                // Par exemple :
                // Minion Pro | Regular
                // Minion Pro | Bold
                //
                // Nous combinons donc famille + style.
                var key =
                    font.fontFamily +
                    " | " +
                    font.fontStyleName;


                // ---------------------------------------------------
                // 9. Ajouter la police seulement si elle
                //    n'a pas encore été rencontrée
                // ---------------------------------------------------

                if (!fonts[key]) {

                    fonts[key] = {

                        // Nom de la famille typographique.
                        family: font.fontFamily,

                        // Variante de la police :
                        // Regular, Bold, Italic, Light, etc.
                        style: font.fontStyleName,

                        // Nom technique PostScript.
                        postscript: font.postscriptName
                    };
                }

            } catch (e) {

                // Certaines situations particulières peuvent provoquer
                // une erreur lors de la lecture d'un caractère.
                //
                // Plutôt que d'interrompre tout le script,
                // nous ignorons simplement ce caractère.
            }
        }
    }
}


// ---------------------------------------------------------------
// 10. Construire le contenu du fichier CSV
// ---------------------------------------------------------------

// Première ligne : noms des colonnes.
//
// \r\n correspond à un retour à la ligne compatible
// avec les principaux tableurs.
var csv =
    "Font Family,Style,PostScript Name\r\n";


// ---------------------------------------------------------------
// 11. Ajouter les polices au fichier CSV
// ---------------------------------------------------------------

for (var key in fonts) {

    // Les valeurs sont entourées de guillemets.
    //
    // replace(/"/g, '""') permet d'échapper les éventuels
    // guillemets contenus dans les données.
    //
    // Cette méthode respecte la syntaxe classique d'un CSV.
    csv +=
        '"' +
        fonts[key].family.replace(/"/g, '""') +
        '","' +

        fonts[key].style.replace(/"/g, '""') +
        '","' +

        fonts[key].postscript.replace(/"/g, '""') +
        '"\r\n';
}


// ---------------------------------------------------------------
// 12. Demander à l'utilisateur où enregistrer le fichier
// ---------------------------------------------------------------

// Une boîte de dialogue système apparaît.
//
// L'utilisateur peut choisir :
// - le dossier ;
// - le nom du fichier.
var file =
    File.saveDialog(
        "Enregistrer la liste des polices au format CSV",
        "*.csv"
    );


// ---------------------------------------------------------------
// 13. Enregistrer le fichier
// ---------------------------------------------------------------

// Si l'utilisateur annule la fenêtre,
// la variable file ne contient aucune valeur.
//
// Nous vérifions donc qu'un fichier a bien été choisi.
if (file) {

    // Utilisation de l'encodage UTF-8.
    //
    // Cela permet notamment de gérer correctement
    // les caractères accentués.
    file.encoding = "UTF-8";


    // Ouverture du fichier en mode écriture.
    //
    // "w" signifie "write".
    file.open("w");


    // Écriture de toutes les données CSV.
    file.write(csv);


    // Fermeture du fichier.
    file.close();


    // Confirmation destinée à l'utilisateur.
    alert(
        "La liste des polices a été exportée avec succès."
    );
}

// ================================================================
// Adobe InDesign
// Export de toutes les polices réellement utilisées dans le document
// vers un fichier CSV.
//
// Le script récupère :
// - la famille de la police ;
// - le style de la police ;
// - le nom PostScript.
//
// Le fichier CSV peut ensuite être ouvert dans Excel,
// LibreOffice Calc, Numbers ou Google Sheets.
// ================================================================


// ---------------------------------------------------------------
// 1. Vérifier qu'un document InDesign est ouvert
// ---------------------------------------------------------------

// app.documents représente la collection des documents
// actuellement ouverts dans InDesign.
//
// Si sa longueur est égale à zéro, aucun document n'est ouvert.
if (app.documents.length === 0) {

    // Affiche un message à l'utilisateur.
    alert("Aucun document InDesign n'est ouvert.");

    // Interrompt immédiatement l'exécution du script.
    exit();
}


// ---------------------------------------------------------------
// 2. Récupérer le document actif
// ---------------------------------------------------------------

// app.activeDocument correspond au document actuellement sélectionné.
var doc = app.activeDocument;


// ---------------------------------------------------------------
// 3. Créer un objet destiné à mémoriser les polices
// ---------------------------------------------------------------

// Cet objet va servir de dictionnaire.
//
// Chaque police rencontrée sera enregistrée une seule fois,
// même si elle apparaît plusieurs centaines de fois dans le document.
var fonts = {};


// ---------------------------------------------------------------
// 4. Récupérer toutes les stories du document
// ---------------------------------------------------------------

// Une "story" InDesign représente un flux de texte.
//
// Un même flux peut traverser plusieurs blocs de texte chaînés.
//
// getElements() transforme la collection InDesign
// en éléments que nous pouvons parcourir avec une boucle.
var stories = doc.stories.everyItem().getElements();


// ---------------------------------------------------------------
// 5. Parcourir toutes les stories
// ---------------------------------------------------------------

for (var i = 0; i < stories.length; i++) {

    // textContainers contient les blocs qui accueillent
    // le texte de cette story.
    var textFrames = stories[i].textContainers;


    // -----------------------------------------------------------
    // 6. Parcourir les blocs de texte
    // -----------------------------------------------------------

    for (var j = 0; j < textFrames.length; j++) {

        // Récupération du contenu textuel du bloc.
        var text = textFrames[j].texts[0];


        // -------------------------------------------------------
        // 7. Analyser chaque caractère
        // -------------------------------------------------------

        // Nous examinons chaque caractère afin d'identifier
        // précisément la police réellement appliquée au texte.
        for (var k = 0; k < text.characters.length; k++) {

            try {

                // Récupération de la police appliquée
                // au caractère courant.
                var font = text.characters[k].appliedFont;


                // ---------------------------------------------------
                // 8. Construire une clé unique
                // ---------------------------------------------------

                // Une même famille peut exister dans plusieurs styles.
                //
                // Par exemple :
                // Minion Pro | Regular
                // Minion Pro | Bold
                //
                // Nous combinons donc famille + style.
                var key =
                    font.fontFamily +
                    " | " +
                    font.fontStyleName;


                // ---------------------------------------------------
                // 9. Ajouter la police seulement si elle
                //    n'a pas encore été rencontrée
                // ---------------------------------------------------

                if (!fonts[key]) {

                    fonts[key] = {

                        // Nom de la famille typographique.
                        family: font.fontFamily,

                        // Variante de la police :
                        // Regular, Bold, Italic, Light, etc.
                        style: font.fontStyleName,

                        // Nom technique PostScript.
                        postscript: font.postscriptName
                    };
                }

            } catch (e) {

                // Certaines situations particulières peuvent provoquer
                // une erreur lors de la lecture d'un caractère.
                //
                // Plutôt que d'interrompre tout le script,
                // nous ignorons simplement ce caractère.
            }
        }
    }
}


// ---------------------------------------------------------------
// 10. Construire le contenu du fichier CSV
// ---------------------------------------------------------------

// Première ligne : noms des colonnes.
//
// \r\n correspond à un retour à la ligne compatible
// avec les principaux tableurs.
var csv =
    "Font Family,Style,PostScript Name\r\n";


// ---------------------------------------------------------------
// 11. Ajouter les polices au fichier CSV
// ---------------------------------------------------------------

for (var key in fonts) {

    // Les valeurs sont entourées de guillemets.
    //
    // replace(/"/g, '""') permet d'échapper les éventuels
    // guillemets contenus dans les données.
    //
    // Cette méthode respecte la syntaxe classique d'un CSV.
    csv +=
        '"' +
        fonts[key].family.replace(/"/g, '""') +
        '","' +

        fonts[key].style.replace(/"/g, '""') +
        '","' +

        fonts[key].postscript.replace(/"/g, '""') +
        '"\r\n';
}


// ---------------------------------------------------------------
// 12. Demander à l'utilisateur où enregistrer le fichier
// ---------------------------------------------------------------

// Une boîte de dialogue système apparaît.
//
// L'utilisateur peut choisir :
// - le dossier ;
// - le nom du fichier.
var file =
    File.saveDialog(
        "Enregistrer la liste des polices au format CSV",
        "*.csv"
    );


// ---------------------------------------------------------------
// 13. Enregistrer le fichier
// ---------------------------------------------------------------

// Si l'utilisateur annule la fenêtre,
// la variable file ne contient aucune valeur.
//
// Nous vérifions donc qu'un fichier a bien été choisi.
if (file) {

    // Utilisation de l'encodage UTF-8.
    //
    // Cela permet notamment de gérer correctement
    // les caractères accentués.
    file.encoding = "UTF-8";


    // Ouverture du fichier en mode écriture.
    //
    // "w" signifie "write".
    file.open("w");


    // Écriture de toutes les données CSV.
    file.write(csv);


    // Fermeture du fichier.
    file.close();


    // Confirmation destinée à l'utilisateur.
    alert(
        "La liste des polices a été exportée avec succès."
    );
}

Étape 5 — Lancer le script dans InDesign

Une fois le fichier enregistré dans le dossier des scripts utilisateur, revenez dans InDesign.

Le fichier devrait apparaître automatiquement dans :

Fenêtre → Utilitaires → Scripts → User

Vous devriez voir :

ExportFonts.jsx

Double-cliquez simplement dessus.

Le script commence alors l’analyse du document.

À la fin, une fenêtre vous demande où enregistrer le fichier CSV.

Vous pouvez par exemple choisir :

polices-document.csv

Sur macOS : où enregistrer le CSV ?

La boîte de dialogue utilise le sélecteur de fichiers standard de macOS.

Vous pouvez par exemple enregistrer le fichier :

• sur le Bureau ;
• dans Documents ;
• dans le dossier du projet InDesign ;
• dans un dossier partagé avec votre équipe.

Une fois le fichier créé, vous pouvez l’ouvrir avec :

• Microsoft Excel ;
• Apple Numbers ;
• LibreOffice Calc ;
• Google Sheets après importation.

Sous Windows : où enregistrer le CSV ?

La boîte de dialogue utilise l’Explorateur de fichiers Windows.

Vous pouvez enregistrer le CSV :

• sur le Bureau ;
• dans Documents ;
• dans le dossier de votre projet ;
• sur un serveur ;
• dans un dossier OneDrive.

Le fichier peut ensuite être ouvert avec Excel ou LibreOffice Calc.

Que contient le fichier CSV ?

Le script crée trois colonnes :

Font Family,Style,PostScript Name

Un fichier généré pourrait ressembler à ceci :

"Minion Pro","Regular","MinionPro-Regular"
"Minion Pro","Bold","MinionPro-Bold"
"Helvetica Neue","55 Roman","HelveticaNeue-Roman"
"Helvetica Neue","75 Bold","HelveticaNeue-Bold"

Une fois ouvert dans un tableur, le résultat devient beaucoup plus lisible.

Comment fonctionne le script ?

Le principe est relativement simple.

Le script commence par récupérer le document actif :

var doc = app.activeDocument;

var doc = app.activeDocument;

Il récupère ensuite toutes les stories du document.

Dans InDesign, une story correspond à un flux de texte.

Si vous avez par exemple trois blocs de texte chaînés, ils peuvent appartenir à une seule et même story.

var stories =
    doc.stories.everyItem().getElements();

var stories =
    doc.stories.everyItem().getElements();

Le script parcourt ensuite chaque bloc de texte et chaque caractère.

Pour chaque caractère, il demande à InDesign quelle police est appliquée :

var font =
    text.characters[k].appliedFont;

var font =
    text.characters[k].appliedFont;

Il peut ensuite récupérer différentes propriétés de la police :

font.fontFamily
font.fontStyleName
font.postscriptName

font.fontFamily
font.fontStyleName
font.postscriptName

Pourquoi analyser les caractères individuellement ?

On pourrait être tenté de simplement analyser les blocs de texte.

Le problème est qu’un seul bloc peut contenir plusieurs polices.

Prenons par exemple la phrase :

Découvrez notre nouvelle collection.

Le mot « Découvrez » pourrait être en Helvetica Neue Bold tandis que le reste de la phrase utilise Helvetica Neue Regular.

En analysant les caractères individuellement, le script peut détecter ces deux variantes.

Cette approche donne donc une vision plus précise des polices réellement utilisées dans le contenu.

Pourquoi utiliser un objet fonts ?

Supposons qu’un document contienne 150 000 caractères en Minion Pro Regular.

Nous ne voulons évidemment pas obtenir 150 000 lignes identiques dans le fichier CSV.

Le script utilise donc un objet JavaScript :

var fonts = {};

var fonts = {};

La combinaison suivante sert de clé :

font.fontFamily + " | " + font.fontStyleName

font.fontFamily + " | " + font.fontStyleName

Par exemple :

Minion Pro | Regular
Minion Pro | Bold
Helvetica Neue | 55 Roman

Minion Pro | Regular
Minion Pro | Bold
Helvetica Neue | 55 Roman

Avant d’enregistrer une police, le script vérifie qu’elle n’a pas déjà été ajoutée :

if (!fonts[key]) {

if (!fonts[key]) {

Chaque combinaison famille/style n’apparaît donc qu’une seule fois dans le CSV.

Pourquoi exporter également le nom PostScript ?

Le nom affiché dans InDesign n’est pas toujours exactement le même que le nom technique de la police.

Par exemple :

Famille : Minion Pro
Style : Regular
PostScript : MinionPro-Regular

Famille : Minion Pro
Style : Regular
PostScript : MinionPro-Regular

Le nom PostScript peut être particulièrement utile dans les environnements :

• prépresse ;
• impression professionnelle ;
• PDF ;
• automatisation ;
• catalogues de polices ;
• scripts ;
• outils de gestion typographique.

Il permet également de distinguer plus précisément certaines variantes.

Une limite importante de cette méthode

Le script présenté ici recherche les polices réellement appliquées à des caractères présents dans les blocs de texte analysés.

Cela signifie qu’il est principalement destiné à répondre à la question :

Quelles polices sont réellement utilisées par le texte de mon document ?

Mais un document InDesign peut contenir des références à des polices qui ne sont actuellement appliquées à aucun caractère.

Cela peut notamment arriver dans :

• des styles de paragraphe ;
• des styles de caractère ;
• des blocs de texte vides ;
• certains éléments de gabarit ;
• des styles importés mais inutilisés ;
• des éléments masqués ;
• certains contenus conditionnels.

Dans ces situations, une analyse plus complète du document est nécessaire.

Différence entre une police utilisée et une police référencée

Cette distinction est importante pour comprendre le résultat.

Une police utilisée est réellement appliquée à du texte présent dans le document.

Par exemple :

Helvetica Neue Bold

est utilisée si au moins un caractère du document utilise cette police.

Une police référencée, en revanche, peut simplement être enregistrée dans un style.

Imaginons un style de paragraphe nommé :

Citation

utilisant :

Garamond Premier Pro Italic

Si aucun paragraphe du document n’utilise actuellement ce style, Garamond peut être présente dans la définition du style sans être utilisée dans le texte.

Notre script simple ne détectera pas nécessairement cette situation.

Vers un véritable inventaire prépresse

Pour une utilisation professionnelle, notamment avant l’envoi d’un fichier chez un imprimeur ou à un autre graphiste, il peut être intéressant de créer une version plus complète du script.

Cette version pourrait exporter, pour chaque police :

• la famille ;
• le style ;
• le nom PostScript ;
• le nombre de caractères utilisant la police ;
• le nombre d’occurrences ;
• les styles de paragraphe qui utilisent la police ;
• les styles de caractère qui utilisent la police ;
• les pages sur lesquelles elle apparaît ;
• les éléments de gabarit concernés ;
• le statut de la police ;
• les éventuelles polices manquantes.

On pourrait par exemple obtenir un CSV de ce type :

Ce type d’inventaire devient particulièrement utile dans un workflow de prépresse, c’est-à-dire l’ensemble des vérifications et préparations effectuées avant l’impression professionnelle.

Une amélioration possible : compter les caractères

Notre objet contient actuellement trois propriétés :

fonts[key] = {
    family: font.fontFamily,
    style: font.fontStyleName,
    postscript: font.postscriptName
};

fonts[key] = {
    family: font.fontFamily,
    style: font.fontStyleName,
    postscript: font.postscriptName
};

Il serait possible d’ajouter un compteur :

fonts[key] = {
    family: font.fontFamily,
    style: font.fontStyleName,
    postscript: font.postscriptName,
    count: 0
};

fonts[key] = {
    family: font.fontFamily,
    style: font.fontStyleName,
    postscript: font.postscriptName,
    count: 0
};

Puis d’incrémenter ce compteur chaque fois que la police est rencontrée :

fonts[key].count++;

fonts[key].count++;

Le CSV pourrait alors indiquer approximativement l’importance de chaque police dans le document.

Une police utilisée sur 50 000 caractères n’a en effet pas la même importance qu’une police utilisée sur un seul symbole oublié dans un bloc.

Cette information peut être très utile lorsqu’on cherche à nettoyer un document.

Une amélioration possible : détecter les polices manquantes

InDesign sait également qu’une police référencée dans un document est indisponible.

Une version plus avancée du script pourrait analyser l’état de chaque police et créer une colonne supplémentaire :

Status

Status

avec par exemple :

Installed
Missing
Substituted

Installed
Missing
Substituted

Une telle fonction permettrait de transformer le script en véritable outil de contrôle avant production.

Une amélioration possible : afficher les pages concernées

Autre fonction intéressante : mémoriser les pages sur lesquelles chaque police est utilisée.

Le fichier pourrait alors contenir :

Cela permettrait de retrouver rapidement une police problématique sans devoir parcourir manuellement tout le document.

CSV ou TXT : lequel choisir ?

Le CSV est généralement le format le plus pratique lorsque les données doivent être analysées dans un tableur.

CSV signifie Comma-Separated Values, c’est-à-dire « valeurs séparées par des virgules ».

Il est adapté à Excel, Numbers, LibreOffice Calc et Google Sheets.

Un fichier TXT peut cependant être intéressant lorsqu’on souhaite simplement obtenir une liste lisible.

Par exemple :

Minion Pro — Regular
Minion Pro — Bold
Helvetica Neue — 55 Roman
Helvetica Neue — 75 Bold

La modification du script pour produire un fichier texte est relativement simple.

Il suffit de construire le contenu sous cette forme :

// Création d'une chaîne de texte vide.
var txt = "";

// Parcours de toutes les polices trouvées.
for (var key in fonts) {

    // Une police est ajoutée par ligne.
    txt +=
        fonts[key].family +
        " - " +
        fonts[key].style +
        " - " +
        fonts[key].postscript +
        "\r\n";
}

// Création d'une chaîne de texte vide.
var txt = "";

// Parcours de toutes les polices trouvées.
for (var key in fonts) {

    // Une police est ajoutée par ligne.
    txt +=
        fonts[key].family +
        " - " +
        fonts[key].style +
        " - " +
        fonts[key].postscript +
        "\r\n";
}

Puis d’utiliser :

// Affichage d'une boîte de dialogue demandant
// où enregistrer le fichier texte.
var file =
    File.saveDialog(
        "Enregistrer la liste des polices",
        "*.txt"
    );

// Affichage d'une boîte de dialogue demandant
// où enregistrer le fichier texte.
var file =
    File.saveDialog(
        "Enregistrer la liste des polices",
        "*.txt"
    );

Où peut-on aller plus loin avec les scripts InDesign ?

L’export des polices n’est qu’un exemple relativement simple de ce qu’il est possible d’automatiser.

Le même principe permet de créer des scripts capables de :

• exporter toutes les couleurs d’un document ;
• lister les styles de paragraphe ;
• détecter les images en basse résolution ;
• rechercher les images manquantes ;
• exporter les dimensions des images ;
• vérifier les fonds perdus ;
• analyser les liens ;
• détecter les blocs contenant du texte en excès ;
• créer automatiquement des rapports prépresse ;
• générer des catalogues ;
• produire des documents à partir de données CSV ou JSON.

Il devient même possible de créer un script générant automatiquement un rapport d’audit complet contenant les polices, les images, les couleurs, les pages problématiques et les ressources manquantes.