TSPoet

TSPoet est une bibliothèque TS/JS pour générer des fichiers source .ts

La génération de fichier .ts pourras vous être utile lors d’exécution de processus en générant du code TypeScript (par exemple : lors d’une exécution d’une commande NPM).

Installation

Mise à jour importante

• Version en cours: 3.0.11-beta01

Les fichiers 7z commençant par l'expression _latest[...].7z à l'emplacement ./node_modules/@msay2/tspoet/ sont les anciennes versions de TSPoet ainsi que la version courante

Supprimer le dossier lib et décompresser le dossier voulut

Un fichier 7z de la version en cours de production est livré pour les éventuelles erreurs de supressions ou pour revenir à la version courante.

Le développement de TSPoet est très lent pour la simple raison que je ne reçois aucune demande d'amélioration et/ou d'information, de ce fait je ne peux savoir si cette bibliothèque convient (dans l'ensemble) ou pas

Les seules améliorations qui sont apportées à TSPoet sont les améliorations que JE constate, je pense que « Pas de nouvelles égal Bonnes nouvelles » 😏

Le language TypeScript est assez riche et n'est pas vraiment (je vulgarise) "Conventionnelle", vous pouvez développer des projets TypeScript/JavaScript de plusieurs façons, il y en a pas qu'une seule façon de mettre sur pied des projets Web JavaScript/TypeScript, JavaScript est un langage assez "ennouer" et retranscrire tous ces noeuds n'est pas un but à atteindre pour TSPoet.

TSPoet est une bibliothèque minimaliste, seulement un assistant pour créer des objets TypeScript. (si possible) TSPoet vous permettra de créer votre propre architecture TypeScript

Si vous avez des idées d'améliorations, des suggestions, n'hésitez pas à me contacter sur mon adresse Gmail [email protected]

👋🏽 Bonne journée/soirée/nuit.

Si vous êtes sur une version antérieure à la version 3.0.9-beta, veuillez jeter un oeil au journal des modifications et au didacticiel.

La version 3.0.9-beta est une grosse mise à jour qui ajoute, supprime et renomme beaucoup d'éléments.

3.0.11-beta01

• Aucune amélioration apportée, seulement le fichier README.md est changé

3.0.11-beta

• Fichiers *.d.ts mis à jour (petite correction).

3.0.10-beta

• Corrections mineures.

3.0.9-beta

• Cette version permet de créer des classes imbriquées.
• Suppression des objets TSObject, TSVariable et TypeName.
• Ajout de nouveaux objets TSField et ObjectName.
• Suppression des méthodes TSType.Builder.addImport, TSPoet.writeInFile, TSPoet.createFileStream, TSType.customElementBuilder et TSType.declarableBuilder
• TSPoet instaure maintenant une convention générique des noms d'accès aux générateurs d'éléments, TSExemple.exempleBuilder, TSCornichon.cornichonBuilder, TSPokemon.pokemonBuilder ...etc.
• Tous les objets utilisant le nom de méthode transtypeTo change de nom pour cast.
• L'objet TSAnnotation est maintenant déprécié, il sera probablement supprimé dans la prochaine ou quelques mises à jour.
• Amélioration du générateur de lignes de codes. (Grosse amélioration, d'où la version Bêta)
• Amélioration de l'objet Modifier

3.0.6-beta

• Amélioration du générateur de lignes de codes (tentative).

3.0.5-beta

• Amélioration du générateur de lignes de codes (tentative).
• Suppression du journal des modifications.

3.0.4

• Amélioration.

3.0.3

• la version 14.9.0 de nodeJS est requise.

3.0.2

• Mise à jour du fichier README.md.

3.0.1

• L'objet TSProperty peut être importé.

3.0.0

• Grosse Mise à jour (Fichiers renommés, Nouvelles fonctionnalités, Méthodes renommées, Objets supprimées, Corrections de bogues).
• Mise à jour des fichiers :
  • README.md
  • *.d.ts
• Nouvelles fonctionnalités :
  • Vous pouvez ajouter des documentations.
  • Vous pouvez ajouter des commentaires.
• Améliorations :
  • Correction de l'insertion d'indentations inutiles.
  • l'objet TSInterfaceMethod supprimé.
  • l'objet TSParameter supprimé.
  • l'objet TSImport supprimé.
  • l'objet TSProperty Créer.
  • TSConstant.addDoc (Ajoutée).
  • ClassBuilder.addDoc (Ajoutée).
  • EnumBuilder.addDoc (Ajoutée).
  • InterfaceBuilder.addDoc (Ajoutée).
  • InterfaceBuilder.addMethod (supprimée).
  • TSMethod.addDoc (Ajoutée).
  • TSConstant.get (supprimée) remplacée par TSConstant.add.
  • CodeBlock.newBlock (supprimée) remplacée par CodeBlock.new.
  • CodeBlock.addComment (ajoutée).
  • Le méthode addParameter des objets InterfaceBuilder et TSMethod ne prenent plus l'objet TSParameter en paramètre addParameter(path, nameClasses).
  • La méthode addProperty prend l'objet TSProperty en paramètre.

2.1.3

• Ajout d'un retour à la ligne pour des générations de fichiers.

2.1.2

• Ajout du modificateur READONLY
• Nouvelles fonctionnalités :
  • Déclaration de type
  • Déclaration de variable
• Mise à jour des fichiers *.d.ts.
• Mise à jour du fichier README.md.

2.0.2

• MISE À JOUR DE LA LICENCE (APACHE 2.0).
• Mise à jour des fichiers *.d.ts.
• Ajout d’un référentiel des mises à jour.
• Mise à jour du fichier package.json.
• Mise à jour du fichier README.md.

2.0 [Production]

• Mise à jour du fichier README.md.
• Mise à jour des fichiers *.d.ts.

0.0.44 [Bêta]

• Initialisation (version bêta).

0.0.1 [Alpha]

• Initialisation (version alpha).

TSPoet peut s’exécuter avec les fichiers .mjs

cli.mjs

import tspoet from "@msay2/tspoet";
const { TSType, TSMethod, Modifier, ObjectName } = tspoet;

Exemple

Voici un code simple

import { Manager } from "./build/generated/Manager.js";

export class Fragment extends Manager
{
	public onView():void{
		super.onView();
	}
}

Voici son équivalant généré avec TSPoet (dont le fichier TypeScript portera le même nom que son nom de classe).

let objectManager = ObjectName.get("./build/generated", "Manager")
let objectFragment = ObjectName.get(undefined, "Fragment");

let fragmentClassBuilder = TSType.classBuilder(objectFragment)
    .addModifiers(Modifier.EXPORT)
    .setSuperclass(objectManager);

let frgamentOnViewMethod = TSMethod.methodBuilder("onView")
    .addModifiers(Modifier.PUBLIC)
    .return(ObjectName.VOID)
    .addStatement("super.onView();");

fragmentClassBuilder.addMethod(frgamentOnViewMethod.build());

TSPoet.writeFile("app/", fragmentClassBuilder.build());

Pour déclarer notre classe Fragment ainsi que sa méthode Fragment.onView nous devons entamer la création d’un type d’élément TypeScript avec l’object TSType.
Nous configurons la classe Fragment en y ajoutant une importation, puis en ajoutant un modificateur qui configurera la portée de notre classe, ensuite nous ajoutons une classe à étendre de l’objet Manager.
Une fois la configuration de la classe Fragment nous devons ajouter une méthode d’implémentation à notre classe avec l’objet TSMethod que l’on nomme onView.
La méthode Fragment.onView sera configurée avec une portée public puis avec une valeur de retour typée void puis nous ajoutons une ligne de code.

Une fois les configurations terminées, nous pouvons « écrire » notre fichier en demandant à l’objet TSPoet de créer notre futur objet à partir des configurations du/des générateurs cités plus haut, avec la méthode TSPoet.writeFile.

• Classes --> TSType.classBuilder
• Interfaces --> TSType.interfaceBuilder
• Énumérations --> TSType.enumBuilder
• Implémentation anonyme --> TSType.anonymousImplBuilder

La configuration des méthodes, propriétées …etc n’étant pas modélisées, tous les paramètres appliqués pour la configuration de vos objets sont modélisés par TSPoet par de simples chaînes de caractères, ainsi que vos lignes de codes :

let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(ObjectName.VOID)
    .addStatement("let index:number = 0;" +
    "let value:boolean = true;" +
    "while (value)" +
    "{" +
    "console.log(`Index=[${value}]`);" +
    "index++;" +
    "if (index == 20)" +
    "{" +
    "value = false;" +
    "}" +
    "}")
    .build();

Ce qui générerait :

doLoop():void{
	let index:number = 0;let value:boolean = true;while (value){console.log(`Index=[${value}]`);index++;if (index == 20){value = false;}}
}

Pour remédier à ce genre de pratique fastidieuse, TSPoet comprend l’objet CodeBlock qui vous permet d’écrire vos ligne de code bloc par bloc :

let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(ObjectName.VOID)
    .addCodeBlock(CodeBlock.new()
        .addStatement("let index:number = 0, value:boolean = true")
        .beginBrace("while (value)")
        .addStatement("console.log(`Index=[${value}]`)")
        .addStatement("index++")
        .beginBrace("if (index == 20)")
        .addStatement("value = false")
        .endBrace()
        .endBrace()
        .build())
    .build();

Ce qui générerait :

doLoop():void{
    let index:number = 0, value:boolean = true;
    while (value){
        console.log(`Index=[${value}]`);
        index++;
        if (index == 20){
            value = false;
        }
    }
}

Concrètement, l’objet CodeBlock vous permet d’ajouter du code complexe, contrairement à la méthode par défaut TSMethod.addStatement qui vous permet d’ajouter vos lignes de codes SIMPLEMENT.
L'utilisation de l'objet CodeBlock est recommandé, celui-ci gère les indentations, les accolades et les points-virgule.

La méthode CodeBlock.addStatement insert vos lignes de codes et gère les indentation et les points-virgule.
La méthode CodeBlock.beginBrace insert une accolade ouvrante en fin d'instruction.
La méthode CodeBlock.endBrace insert une accolade fermante en fin d'instruction.
La méthode CodeBlock.nextBrace insert une accolade fermante puis ouvrante avant et fin d'instruction.

Créations

Classes

Créer une classe

let componentClassBuilder = TSType.classBuilder(ObjectName.get(undefined, "Component")).build();

Ce qui générerait

class Component
{
}

Un fichier TypeScript sera généré au nom de votre classe (soit Component.ts)

Interfaces

Créer une interface

let managerInterfaceBuilder = TSType.interfaceBuilder(ObjectName.get(undefined, "Manager")).build();

Ce qui générerait

interface Manager
{
}

Enumérations

Créer une énumération

let managerEventEnumBuilder = TSType.enumBuilder(ObjectName.get(undefined, "EventManager")).build();

Ce qui générerait

enum EventManager
{
}

Création du fichier TS et génération du type d'objet

Créer l'objet configuré

let classBuilder = ...;


TSPoet.writeFile("./app", classBuilder.build());

Ce qui générerait un ficher TypeScript au nom de votre objet classBuilder dans un dossier nommé app.

Bloc de code (bonnes pratiques)

L’objet CodeBlock possède une fonctionnalité vous permettant de ne plus écrire du code fastidieux (comprenant plusieurs caractères additionnelles pour la concaténation d’expressions littérales).

Pratiques

« Mauvaise » pratique

let enableChatBuilder = TSMethod.methodBuilder("enableChat")
    .addCodeBlock(CodeBlock.new()
        .addStatement("let count:number = 0")
        .beginBrace("for (let i:number = 0; i < 20; i++)")
        .addStatement("count += i")
        .endBrace()
        .buil())
    .build();

Pratique moins mauvaise

public static createMethod(from:number, to:number):void
{
    let counterBuilder = TSMethod.methodBuilder("counter")
        .addCodeBlock(CodeBlock.new()
            .addStatement("let count:number = 0")
            .beginBrace("for (let i:number = "+ from +"; i < "+ to +"; i++)")
            .addStatement("count += i")
            .endBrace()
            .buil())
        .build();
}

Pour éviter ces « mauvaises » pratiques, CodeBlock possède 4 expressions qui vous permet d’éviter toutes les concaténations « agaçantes ».

Bonne pratiques

let counterBuilder = TSMethod.methodBuilder("counter")
    .addCodeBlock(CodeBlock.new()
        .addStatement("let count:number = 0")
        .beginBrace("for (let i:number = $L; i < $L; i++)", 0, 20)
        .addStatement("count += i")
        .endBrace()
        .buil())
    .build();

L’objet CodeBlock vous donne la possibilité d’insérer vos lignes de code de manière similaire à la méthode string.replace.

Pour les expressions littérales

…
.beginBrace("for (let i:number = $L; i < $L; i++)", 0, 20)
…

Pour les chaînes de caractères

…
.beginBrace("let firstName:string = $S, lastName:string = $S", "Manon", "Carcer")
…

Pour les objets

…
.beginBrace("let myObject:$O = new $O()", ObjectName.get(undefined, "MyObject"), ObjectName.get(undefined, "MyObject"))
…

Pour les implémentations anonymes

…
.addStatement("let impl:any = $I", TSType.anonymousImplBuilder().build())
…

Importations

Les importations se font "automatiquement" avec l'objet ObjectName, pour ce faire vous devez simplement fournir le chemin d'accès valide de votre fichier par rapport à l'emplacement de votre futur type d'objet à générer.
L'objet ObjectName prend en paramètre 3 variables :

• (Annulable) Le nom d'accès du fichier.
• Le nom de l'objet.
• (Optionnel) Les noms des classes imbriquées.

ObjectName permet également le transtypage d'objets
Vous ne pouvez pas ajouter un objet à importer si il est utilisé nulle part

/!\ Avertissement /!\

ObjectName vous impose une convention strict sur sont utilisation, soit 1 Fichier = 1 Objet, si votre fichier contient plusieurs objets exportables, vos objets (sauf mentionné avec l'objet ObjectName) ne seront pas explicitement inscrit dans l'instruction import, cela signifie que, 1 Objet = 1 Exportable
Donc : 1 Fichier = 1 (ou plusieurs) Objet(s) = 1 Exportable.

Méthodes

Note : Si vous appliquez un modificateur abstrait à un générateur de méthode qui est pourvus d’une ligne de code (ou d’un bloc de code), ces dernières seront ignorées du fait que les méthodes abstraites ne doivent pas avoir de corp.

Créer une méthode

Note : Le générateur de méthode vérifiera toujours si votre méthode à générer possède une type de retour car il ne possède pas de valeur par défaut.

let checkValueBuilder = TSMethod.methodBuilder("checkValue")
    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT);

// checkValueBuilder lèvera une exception car il ne contient aucun type de retour.

let checkerBuilder = TSMethod.methodBuilder("checker")
    .addModifiers(Modifier.PUBLIC)
    .return(ObjectName.VOID);

let checkClassBuilder = TSType.classBuilder(ObjectName.get(undefined, "Checker"))
    .addModifiers(Modifier.EXPORT, Modifier.ABSTRACT)
    .addMethod(checkValueBuilder.build())
    .addMethod(checkerBuilder.build())
    .build();

Ce qui générerait

export abstract class Checker
{
	public abstract checkValue():void;

	public checker():void{}
}

Paramètres

let objectContext = ObjectName.get(".", "Context").cast(ObjectName.STRING, ObjectName.BOOLEAN);

let overBuilder = TSMethod.methodBuilder("over")
    .addModifiers(Modifier.PRIVATE)
    .addParameter("value", ObjectName.BOOLEAN)
    .addParameter("name", ObjectName.STRING)
    .addParameter("previousContext", objectContext)
    .addParameter("newestContext", objectContext)
    .return(ObjectName.VOID)
    .build();

Ce qui générerait

import { Context } from "./Context.js"; // Uniquement si le chemin du fichier est spécifié dans l'objet ObjectName

private over(value:boolean, name:string, previousContext:Context<string, boolean>, newestContext:Context<string, boolean>):void{}

Constructeur

let constructorBuilder = TSMethod.constructorBuilder()
    .addModifiers(Modifier.PROTECTED)
    .build();

Ce qui générerait

protected constructor(){}

Variables

let myField = TSField.fieldBuilder("field")
    .addModifiers(Modifier.STATIC)
    .return(ObjectName.ANY)
    .setValue({
        from: 0,
        to: 255
    });

let countField = TSField.fieldBuilder("count")
    .addModifiers(Modifier.PUBLIC)
    .return(ObjectName.NUMBER)
    .setValue(48);

let myFields = TSField.fieldBuilder("fields")
    .addModifiers(Modifier.STATIC)
    .return(ObjectName.get(undefined, "Array").cast(ObjectName.STRING))
    .setValue([
        "Priscilla",
        "Samsung"
    ]);

let fieldsClassBuilder = TSType.classBuilder(ObjectName.get(undefined, "Fields"))
    .addField(myField.build())
    .addField(countField.build())
    .addField(myFields.build())
    .build();

Ce qui générerait

Note : Lève une exception si aucun type de retour est fournie au générateur de variables, soit TSField

class Fields
{
	static field:any = {
		from:0,
		to:255
	};
	public count:number = 48;
	static fields:Array<string> = [
		`Priscilla`,
		`Samsung`
	];
}

Interfaces

let objectArray = ObjectName.get(undefined, "Array").cast(ObjectName.STRING);

let testRobotPropertyBuilder = TSProperty.propertyBuilder("testRobot")
    .addParameter("hasProperties", ObjectName.BOOLEAN)
    .addParameter("list", objectArray)
    .return(objectArray);

let fetcherPropertyBuilder = TSProperty.propertyBuilder("fetcher")
    .return(ObjectName.STRING);

let robotInterface = TSType.interfaceBuilder(ObjectName.get(undefined, "Robot"))
    .addProperty(testRobotPropertyBuilder.build())
    .addProperty(fetcherPropertyBuilder.build());
    .build();

Ce qui générerait

interface Robot
{
	testRobot(hasProperties:boolean, list:Array<string>):Array<string>;
	fetcher():string;
}

Annotations

let object = {
    template: "La confiture c'est trop sucrée"
};
let array = [
    "Celin",
    "Casio"
];

let fooAnnotation = TSAnnotation.annotationBuilder(ObjectName.get(undefined, "Foo")).addValue(object);
let leeAnnotation = TSAnnotation.annotationBuilder(ObjectName.get(undefined, "Lee")).addValue(array);
let barAnnotation = TSAnnotation.annotationBuilder(ObjectName.get(undefined, "Bar")).addValue(TSAnnotation.EMPTY_VALUE);
let booAnnotation = TSAnnotation.annotationBuilder(ObjectName.get(undefined, "Boo"));

let helloBuilder = TSMethod.methodBuilder("hello")
    .addAnnotation(fooAnnotation.build())
    .addAnnotation(leeAnnotation.build())
    .addAnnotation(barAnnotation.build())
    .addAnnotation(booAnnotation.build())
    .return(ObjectName.VOID);

let robotInterface = TSType.classBuilder(ObjectName.get(undefined, "Robot"))
    .addMethod(helloBuilder.build())
    .build();

Ce qui générerait

@Foo({
	template:`La confiture c'est trop sucrée`
})
@Lee([
    `Celin`,
    `Casio`
])
@Bar()
@Boo
hello():void{}

Enumération

let constantUpTouch = TSConstant.constantBuilder("UP", 0);
let constantDownTouch = TSConstant.constantBuilder("DOWN", 1);

let onTouchEnum = TSType.enumBuilder(ObjectName.get(undefined, "OnTouch"))
    .addConstant(constantUpTouch.build())
    .addConstant(constantDownTouch.build())
    .build();

Ce qui générerait

enum OnTouch
{
	UP = 0,
	DOWN = 1
}

Commentaire

Pour ajouter des commentaires vous devez utiliser la méthode CodeBlock.addComment

let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(ObjectName.VOID)
    .addCodeBlock(CodeBlock.new()
        .addStatement("let index:number = 0, value:boolean = true")
        .beginBrace("while (value)")
        .addStatement("console.log(`Index=[${value}]`)")
        .addStatement("index++")
        .addComment("Check if index equals 20")
        .beginBrace("if (index == 20)")
        .addStatement("value = false")
        .endBrace()
        .endBrace()
        .build())
    .build();

Ce qui générerait

private doLoop():void{
    let index:number = 0, value:boolean = true;
    while (value){
        console.log(`Index=[${value}]`);
        index++;
        // Check if index equals 20
        if (index == 20){
            value = false;
        }
    }
}

Documentation

Pour ajouter une documentation vous devez utiliser la méthode addDoc des objets suivants :

• TSType.Builder
• TSConstant
• TSField
• TSMethod
• TSProperty

Insertion des documentations

let setNameMethod = TSMethod.methodBuilder("setName")
    .addModifiers(Modifier.PUBLIC)
    .return(ObjectName.VOID)
    .addDoc("Set the name of user.")
    .addDoc("@param name The name of user.")
    .addParameter("name", ObjectName.STRING)
    .addStatement("this.name = name;")
    .build();

Ce qui générerait

/**
 * Set the name of user.
 * @param name The name of user.
 */
public setName(name:string):void{
    this.name = name;
}

Génération

Pour générer des fichiers TypeScript, vous devez utiliser l’objet TSPoet.

Création + écriture (remplace l'ancien contenu)

let path:string = "app/draw";

let classBuilder = TSType.classBuilder(ObjectName.get(undefined, "MyClass"))
    ...;
let interfaceBuilder = TSType.interfaceBuilder(ObjectName.get(undefined, "MyInterface"))
    ...;
let enumBuilder = TSType.enumBuilder(ObjectName.get(undefined, "MyEnumeration"))
    ...;

TSPoet.writeFile(path, classBuilder.build());
TSPoet.writeFile(path, interfaceBuilder.build());
TSPoet.writeFile(path, enumBuilder.build());

TSPoet utilise les bibliothèques suivantes :

• fs

Référentiel d'objets

TSPoet

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | writeFile | public static | string, TSType | Écrit le type d'élément généré en fournissanst l'emplacement de création de votre fichier ainsi que le type d’élément à créer | TSType.Builder |

TSType

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | classBuilder | public static | ObjectName | Joindre le générateur de classes en fournissant un nom d'objet sans chemin d'accès (notez undefined ou null) | TSType.Builder | | enumBuilder | public static | ObjectName | Joindre le générateur d’énumérations en fournissant un nom d'objet sans chemin d'accès (notez undefined ou null) | TSType.Builder | | interfaceBuilder | public static | ObjectName | Joindre le générateur d’interfaces en fournissant un nom d'objet sans chemin d'accès (notez undefined ou null) | TSType.Builder | | anonymousImplBuilder | public static | X | Joindre le générateur d'implémentations anonymes | TSType.Builder |

TSProperty

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | propertyBuilder | public static | string | Joindre le générateur de propriétés en fournissant son nom | TSProperty.Builder | | addParameter | public | string, ObjectName | Ajoute un paramètre en spécifiant un nom et un nom d'objet | TSProperty.Builder | | addDoc | public | string | Ajoute une documentation | TSProperty.Builder | | return | public | ObjectName | Définie une valeur de retour en spécifiant un nom d'objet | TSProperty.Builder | | build | public | X | Initialise la génération de la propriété | TSProperty |

TSMethod

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | constructorBuilder | public static | X | Joindre le générateur de méthodes en spécifiant un constructeur | TSMethod.Builder | | methodBuilder | public static | string | Joindre le générateur de méthodes en spécifiant un nom | TSMethod.Builder | | addDoc | public | string | Ajoute une documentation | TSMethod.Builder | | addAnnotation | public | TSAnnotation | Ajoute une annotation en spécifiant l'objet TSAnnotation | TSMethod.Builder | | addModifiers | public | ...Modifier | Ajoute des modificateurs | TSMethod.Builder | | addParameter | public | string, ObjectName | Ajoute un paramètre en spécifiant un nom et un nom d'objet | TSMethod.Builder | | addStatement | public | string | Ajoute SIMPLEMENT une ligne d'arguments | TSMethod.Builder | | addCodeBlock | public | CodeBlock | Ajoute un bloc de code | TSMethod.Builder | | cast | public | ...string | Ajoute des arguments génériques | TSMethod.Builder | | return | public | ObjectName | Définie une valeur de retour en spécifiant un nom d'objet | TSMethod.Builder | | build | public | X | Initialise la génération de la méthode | TSMethod |

TSField

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | fieldBuilder | public static | string | Joindre le générateur de variables en spécifiant son nom | TSField.Builder | | addModifiers | public | ...Modifier | Ajoute des modificateurs | TSField.Builder | | addAnnotation | public | TSAnnotation | Ajoute une annotation en spécifiant l'object TSAnnotation | TSField.Builder | | addDoc | public | string | Ajoute une documentation | TSField.Builder | | return | public | ObjectName | Définie une valeur de retour en spécifiant un nom d'objet | TSField.Builder | | setValue | public | any | Définie une valeur à la variable | TSField.Builder | | build | public | X | Initialise le génération de la variable | TSField |

TSConstant

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | constantBuilder | public static | string, any | Joindre le générateur de constantes en spécifiant son nom et sa valeur | TSConstant.Builder | | addDoc | public | string | Ajoute une documentation | TSConstant.Builder | | build | public | X | Initialise la génération de la constante | TSConstant |

TSAnnotation

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | annotationBuilder | public static | ObjectName | Joindre le générateur d'annotations en spécifiant son nom d'objet | TSAnnotation.Builder | | addValue | public | any | Ajoute une valeur à l'annotation | TSAnnotation.Builder | | build | public | X | Initaialise la génération de l'annotation | TSAnnotation |

CodeBlock

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | new | public static | X | Joindre le générateur de bloc de code | CodeBlock.Builder | | addStatement | public | string, ...any | Ajoute une ligne d'arguements en spécifiant (si nécessaire) les annotations à remplacer | CodeBlock.Builder | | addCodeBlock | public | CodeBlock | Ajoute un bloc de code au bloc de code | CodeBlock.Builder | | beginBrace | public | string, ...any | Ajoute un ligne d'arguments suivie d’une accolade ouvrante en spécifiant (si nécessaire) les annotations à remplacer | CodeBlock.Builder | | nextBrace | public | string, ...any | Ajoute une accolade ouvrante, insère une ligne d’arguments et ajoute une accolade fermante en spécifiant (si nécessaire) les annotations à remplacer | CodeBlock.Builder | | endBrace | public | boolean | Ajoute une accolade fermante. Si, nécessaire, ajoute un point-virgule après l'accolade fermante | CodeBlock.Builder | | addComment | public | string | Ajoute un commentaire | CodeBlock.Builder | | build | public | X | Initialise la génération du bloc de code | CodeBlock |

ObjectName

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | get | public static | string, string, ...string | Initialise un nom d'objet | ObjectName | | equals | public | Object | Vérifie si l'instance du nom d'objet est égale l'objet spécifié | ObjectName | | cast | public | ...ObjectName | Transtype le nom d'objet par d'autres noms d'objet | ObjectName |

Modifier

| Méthode | Modificateur | Paramètre | Description | Type | | ------- | ------------ | --------- | ----------- | ---- | | isConstructor | public static | List<Modifier> | Vérifie si la list contient un ou des modificateurs non valides pour un construteur | Modifier | | isSimpleModifier | public static | List<Modifier> | Vérifie si la list contient les modificateurs 'export' ou rien | Modifier | | isNestedClass | public static | List<Modifier> | Vérifie si la list contient un ou des modificateurs valides pour les classes imbriquées | Modifier | | isPrivate | public static | List<Modifier> | Vérifie si la list contient le modificateur 'private' | Modifier | | equals | public | Object | Vérifie si l'instance du modificateur est égale l'objet spécifié | Modifier | | getName | public | number | Obtenir l'identifiant du modificateur | Modifier | | getSimpleName | public | string | Obtenir le nom du modificateur par son identifiant | Modifier |

TSAnnotation

| Champ | Modificateur | Description | Type | | ----- | ------------ | ----------- | ---- | | EMPTY_VALUE | public static | Préviens le générateur que l’annotation ne doit avoir aucune valeur | string |

TSField

| Champ | Modificateur | Description | Type | | ----- | ------------ | ----------- | ---- | | UNDEFINED | public static | Préviens le générateur que la variable doit être intinialisée à la valeur undefined | string |

ObjectName

| Champ | Modificateur | Description | Type | | ----- | ------------ | ----------- | ---- | | OBJECT | public static | nom d'objet faisant référence au type 'object' | ObjectName | | STRING | public static | nom d'objet faisant référence au type 'string' | ObjectName | | BOOLEAN | public static | nom d'objet faisant référence au type 'boolean' | ObjectName | | NUMBER | public static | nom d'objet faisant référence au type 'number' | ObjectName | | VOID | public static | nom d'objet faisant référence au type 'void' | ObjectName | | ANY | public static | nom d'objet faisant référence au type 'any' | ObjectName |

Modifier

| Champ | Modificateur | Description | Type | | ----- | ------------ | ----------- | ---- | | EXPORT | public static | Objet faisant référence au modificateur 'export' | Modifier | | PUBLIC | public static | Objet faisant référence au modificateur 'public' | Modifier | | STATIC | public static | Objet faisant référence au modificateur 'static' | Modifier | | PRIVATE | public static | Objet faisant référence au modificateur 'private' | Modifier | | ABSTRACT | public static | Objet faisant référence au modificateur 'abstract' | Modifier | | PROTECTED | public static | Objet faisant référence au modificateur 'protected' | Modifier | | READONLY | public static | Objet faisant référence au modificateur 'readonly' | Modifier | | UNDEFINED | public static | Objet faisant référence au modificateur '' | Modifier |

License

Copyright (c) 2020-2021 MSay2 (Yoann Meclot) - @msay2/tspoet
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.