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

Journal

Si vous êtes sur une version antérieure à la version 3.0.0 veuillez jeter un oeil au journal des modifications (La version 3.0.0 est une grosse mise à jour qui ajoute, supprime et renomme beaucoup d'elements !)

4.0.0 [Alpha]

• Ne pas installer

3.0.6 [Bêta]

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

3.0.5 [Bêta]

• 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).

Cette bibliothèque peut s’exécuter avec les fichiers .mjs

cli.mjs

import tspoet from "@msay2/tspoet";
const { TSType, TSMethod, Modifier, TypeName} = 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 (don le fichier TypeScript portera le même nom que son nom de classe).

let fragmentClassBuilder = TSType.classBuilder("Fragment")
    .addImport("build/generated/", "Manager")
    .addModifiers(Modifier.EXPORT)
    .setSuperclass(TypeName.get("Manager"));

let frgamentOnViewBuilder = TSMethod.methodBuilder("onView")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_VOID)
    .addStatement("super.onView();"));

fragmentClassBuilder.addMethod(frgamentOnViewBuilder.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 de constructions citées plus haut, avec la méthode TSPoet.writeFile.

/!\ Avertissement /!\

La bibliothèque TSPoet est encore en développement (des changements seront à venir).

TSPoet propose aussi la possibilité de créer des interfaces, énumérations, éléments personnalisées et des déclarations de type ou de variable.

• Classes -> TSType.classBuilder
• Interfaces -> TSType.interfaceBuilder
• Énumérations -> TSType.enumBuilder
• Éléments personnalisées -> TSType.customElementBuilder
• Type ou Var -> TSType.declarableBuilder

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(TypeName.TYPE_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 permettra d’écrire vos ligne de code bloc par bloc :

let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(TypeName.TYPE_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-virgules.

La méthode CodeBlock.addStatement insert vos lignes de codes et gère les indentations.
La méthode CodeBlock.beginBrace insert une accolade ouvrante.
La méthode CodeBlock.endBrace insert une accolade fermante.
La méthode CodeBlock.nextBrace insert une accolade fermante puis ouvrante.

Créations

Classes

Créer une classe

let componentClassBuilder = TSType.classBuilder("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("Manager").build();

Ce qui générerait

interface Manager
{
}

Enumérations

Créer une énumération

let managerEventEnumBuilder = TSType.enumBuilder("EventManager").build();

Ce qui générerait

enum EventManager
{
}

Éléments personnalisés

Créer un élément personnalisé

let viewCustomElementBuilder = TSType.customElementBuilder("my-view")
    .setSuperclass("div")
    .setObject(TSObject.get("MyCustomView"))
    .build();

(lisez plus bas pour en savoir plus sur l'objet TSObject)

Ce qui générerait

customElements.define("my-view", MyCustomView, {extends: "div"});

Déclaration

Type

let declarableBuilder = TSType.declarableBuilder()
    .forType("MyType")
    .addModifiers(Modifier.EXPORT)
    .return(TypeName.TYPE_STRING)
    .build();

Ce qui gégénerait

export declare type MyType = string; 

Var

let interfaceBuilder = TSType.interfaceBuilder("MyInterface")
    .addProperty(TSProperty.add("from")
        .return(TypeName.TYPE_NUMBER)
        .build())
    .addProperty(TSProperty.add("new")
        .addParameter("name", TypeName.TYPE_STRING)
        .build());

let declarableBuilder = TSType.declarableBuilder()
    .forVar()
    .add(interfaceBuilder)
    .build();

Ce qui générerait

declare var MyInterface:
{
    from:number;
    new(name:string):any
}

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 3 expressions vous permettant 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()", TSObject.get("MyObject"), TSObject.get("MyObject"))
…

Importations

let classBuilder = TSType.classBuilder("MyClass")
    .addImport("./", "Map", "LinkedMap")
    .build();

Ce qui générerait

import { Map, LinkedMap } from "./LinkedMap.js";

export class MyClass
{
}

Méthodes

Note : Si vous appliquez un modificateur abstrait à un constructeur 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

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

let checkerBuilder = TSMethod.methodBuilder("checker")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_VOID);

let checkClassBuilder = TSType.classBuilder("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()

	public checker():void{}
}

Paramètres

let overBuilder = TSMethod.methodBuilder("over")
    .addModifiers(Modifier.PRIVATE)
    .return(TypeName.TYPE_VOID)
    .addParameter("value", TypeName.TYPE_BOOLEAN)
    .addParameter("name", TypeName.TYPE_STRING)
    .build();

Ce qui générerait

private over(value:boolean, name:string):void{}

Constructeur

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

Ce qui générerait

protected constructor(){}

Variables

Note : L’objet TSVariable est un constructeur, veillez à toujours appeler la méthode build.

let myVar = TSVariable.add("my_var")
    .addModifiers(Modifier.STATIC)
    .return(TypeName.TYPE_ANY)
    .setValue({
        from: 0,
        to: 255
    });

let countVar = TSVariable.add("count")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_NUMBER)
    .setValue(48);

let vargClassBuilder = TSType.classBuilder("Varg")
    .addVariable(myVar.build())
    .addVariable(countVar.build())
    .build();

Ce qui générerait

class Varg
{
    static my_var:any = {from: 0, to: 255};
    public count:number = 48;
}

Interfaces

Note : L’objet TSProperty est un constructeur, veillez à toujours appeler la méthode build.

let testRobotPropertyBuilder = TSProperty.add("testRobot")
    .addParameter("hasProperties", TypeName.TYPE_BOOLEAN)
    .addParameter("list", TypeName.get("Array").transtypeTo("string"))
    .return(TypeName.get("Array").transtypeTo("string"));

let fetcherPropertyBuilder = TSProperty.add("fetcher")
    .return(TypeName.TYPE_STRING);

let robotInterface = TSType.interfaceBuilder("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

Note : L’objet TSAnnotation est un constructeur, veillez à toujours appeler la méthode build.

let object = {
    template: "<p>Paragraph</p>"
};

let fooAnnotation = TSAnnotation.add("Foo").addValue(object);
let barAnnotation = TSAnnotation.add("Bar").addValue(TSAnnotation.EMPTY_VALUE);
let booAnnotation = TSAnnotation.add("Boo");

let byeBuilder = TSMethod.methodBuilder("bye")
    .addAnnotation(fooAnnotation.build())
    .addAnnotation(barAnnotation.build())
    .addAnnotation(booAnnotation.build())
    .build();

Ce qui générerait

@Foo({
    template: `<p>Paragraph</p>`
})
@Bar()
@Boo
bye(){}

Enumération

Note : L’objet TSConstant est un constructeur, veillez à toujours appeler la méthode build

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

let onTouchEnum = TSType.enumBuilder("OnTouch")
    .addConstant(constantUpTouch.build())
    .addConstant(constantDownTouch.build())
    .build();

Ce qui générerait

enum OnTouch
{
	UP = 0,
	DOWN = 1,
}

Déclaration

Pour créer une déclaration de variable vous devez utiliser l’objet enfant InterfaceBuilder avec la méthode TSType.interfaceBuilder (l’insertion d’une classe à étendre sera ignorée ainsi que son transtypage)

let robotBuilder = TSType.interfaceBuilder("Robot")
    .setSuperclass(TypeName.get("List").transtypeTo("string"))
    .addImport("./", "List", "ArrayList")
    .addModifiers(Modifier.EXPORT)
    .addProperty(TSProperty.add("test")
        .addParameter("hasProperties", TypeName.TYPE_BOOLEAN)
        .addParameter("list", TypeName.get("List").transtypeTo("string", "boolean"))
        .return(TypeName.get("List").transtypeTo("string", "boolean"))
        .build())
    .addProperty(TSProperty.add("new")
        .addParameter("name", TypeName.TYPE_STRING)
        .build())
    .addProperty(TSProperty.add("fetch").return(TypeName.TYPE_STRING))
    .addProperty(TSProperty.add("jaune").return(TypeName.get("List").transtypeTo("string", "boolean")))
    .transtypeTo("B");

let declarableBuilder = TSType.declarableBuilder()
    .forVar()
    .add(interfaceBuilder)
    .build();

Ce qui générerait

import { List, ArrayList } from "./ArrayList.js";
export declare var MyInterface:
{
    test(hasProperties:boolean, list:List<string, boolean>):List<string, boolean>;
    new(name:string):void;
	fetch:string;
	jaune:List<string, boolean>;
}

Pour créer une déclaration de type

let typeDeclarable = TSType.declarableBuilder()
    .forType("Class")
    .addModifiers(Modifier.EXPORT)
    .return(TypeName.TYPE_BOOLEAN)
    .build();

Ce qui générerait

export declare type Class = boolean;

Commentaire

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

let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(TypeName.TYPE_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 :

• ClassBuilder
• EnumBuilder
• InterfaceBuilder
• TSProperty
• TSConstant
• TSMethod

Exemple avec le constructeur de méthode.

let setNameMethod = TSMethod.methodBuilder("setName")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_VOID)
    .addDoc("Set the name of user.")
    .addDoc("@param name the name of user.")
    .addParameter("name", TypeName.TYPE_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.

Écrire dans un fichier en remplaçant l’ancien contenu

let path:string = "app/draw";

let classBuilder = TSType.classBuilder("MyClass")
    ...;
let interfaceBuilder = TSType.interfaceBuilder("MyInterface")
    ...;
let enumBuilder = TSType.enumBuilder("MyEnumeration")
    ...;

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

Écrire dans un fichier sans remplacer l’ancien contenu

let path:string = "app/draw";
let fileName:string = "MyClass";

let classBuilder = ...;
let interfaceBuilder  = ...;
let enumBuilder  = ...;

TSPoet.writeInFile(path, fileName, classBuilder.build());
TSPoet.writeInFile(path, fileName, interfaceBuilder.build());
TSPoet.writeInFile(path, fileName, enumBuilder.build());

Créer un fichier sans contenue

let path:string = "app/draw"
let fileName:string = "MyClass.ts";

TSPoet.createFileStream(path, fileName);

Référentiel d'objets

Objets de modélisations principales

TSType

| Méthodes | Modificateurs | Descriptions | Types | | -------- | ------------- | ------------ | ----- | | classBuilder | public static | Joindre le constructeur de classe | ClassBuilder | | enumBuilder | public static | Joindre le constructeur d’énumération | EnumBuilder | | interfaceBuilder | public static | Joindre le constructeur d’interface | InterfaceBuilder | | customElementBuilder | public static | Joindre le constructeur d’élément personnalisé | CustomElementBuilder | | declarableBuilder | public static | Joindre le constructeur de déclaration de type ou variable | DeclarableBuilder |

ClassBuilder

| Méthodes | Paramètres | Descriptions | Types | | -------- | ---------- | ------------ | ----- | | addImport | string, ...string[] | Ajoute un importation | ClassBuilder | | addDoc | string | Ajoute une documentation | ClassBuilder | | addModifiers | ...Modifier[] | Ajoute des modificateurs | ClassBuilder | | addAnnotation | TSAnnotation | Ajoute une annotation | ClassBuilder | | addMethod | TSMethod | Ajoute une méthode | ClassBuilder | | addVariable | TSVariable | Ajoute une variable | ClassBuilder | | setSuperclass | TypeName | Ajoute une classe à étendre | ClassBuilder | | addInterface | TypeName | Ajoute une interface d'implémentation | ClassBuilder | | transtypeTo | string | Transtype votre classe | ClassBuilder | | build | X | Initialise la construction | TSType |

EnumBuilder

| Méthodes | Paramètres | Descriptions | Types | | -------- | ---------- | ------------ | ----- | | addModifiers | ...Modifier[] | Ajoute des modificateurs | EnumBuilder | | addDoc | string| Ajoute une documentation | EnumBuilder | | addConstant | TSConstant | Ajoute une constante | EnumBuilder | | build | X | Initialise la construction | TSType |

InterfaceBuilder

| Méthodes | Paramètres | Descriptions | Types | | -------- | ---------- | ------------ | ----- | | addImport | string, ...string[] | Ajoute une importation | InterfaceBuilder | | addDoc | string | Ajoute une documentation | InterfaceBuilder | | setSuperclass | TypeName | Ajoute une classe d'extension | InterfaceBuilder | | addModifiers | ...Modifier[] | Ajoute des modificateurs | InterfaceBuilder | | addProperty | TSProperty | Ajoute une méthode ou propriété | InterfaceBuilder | | transtypeTo | string | Transtype votre interface | InterfaceBuilder | | build | X | Initialise la construction | TSType |

CustomElementBuilder

| Méthodes | Paramètres | Descriptions | Types | | -------- | ---------- | ------------ | ----- | | setObject | TSObject | Définie l'objet personnalisé | CustomElementBuilder | | setSuperclass | string | Définie l'objet html à étendre | CustomElementBuilder | | build | X | Initialise la construction | TSType |

DeclarableBuilder

| Méthodes | Paramètres | Description | Types | | -------- | ---------- | ----------- | ----- | | forVar | X | Joindre le constructeur de déclaration de variable | DeclarableVar | | forType | string | Joindre le constructeur de déclaration de type | DeclarableType |

DeclarableVar

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | add | public | InterfaceBuilder | Définie la déclaration de variable. Cette méthode ignore l'insertion de la classe étendue et le transtypage | DeclarableVar | | build | public | X | Initialise la construction de la déclaration | TSType |

DeclarableType

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | addModifiers | public | ...Modifier[] | Ajoute des modificateurs | DeclarableType | | return | public | TypeName | Définie une valeur de retour | DeclarableType | | build | public | X | Initialise la construction de la déclaration |

Objets de modélisations complémentaires

TSProperty

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | add | public static | string | Définie le nom de la propriété ou méthode | Builder | | addParameter | public | string, ...string[] | Ajoute un paramètre | Builder | | addDoc | public | string | Ajoute une documentation | Builder | | return | public | TypeName | Définie une valeur de retour | Builder | | build | public | X | Initialise la construction de la propriété ou méthode | TSProperty |

TSVariable

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | add | public static | string | Ajoute une variable en spécifant son nom | Builder | | addModifiers | public | ...Modifier[] | Ajoute des modificateurs | Builder | | return | public | TypeName | Definie une valeur de retour | Builder | | setValue | public | any | Définie une valeur | Builder | | build | public | X | Initialise la construction de la variable | TSVariable |

TSObject

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | get | public static | string | Définie le nom de l'objet souhaité | TSObject |

TSAnnotation

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | add | public static | string | Définie une annotation | Builder | | addValue | public | any | Ajoute une valeur en paramètre | Builder | | build | public | X | Initialise la construction de l'annotation | TSAnnotation |

TSConstant

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | add | public static | string, string | Définie le nom de la constante | Builder | | addDoc | public | string | Ajoute une documentation | Builder | | build | public | X | Initialise la construction de la constante | TSConstant |

TSMethod

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------ | ---------- | ------------ | ----- | | constructorBuilder | public static | X | Ajoute un constructeur | Builder | | methodBuilder | public static | string | Ajoute une méthode | Builder | | addModifiers | public | ...Modifier[] | Ajoute des modificateurs | Builder | | addDoc | public | string | Ajoute une documentation | Builder | | addAnnotation | public | TSAnnotation | Ajoute une annotation | Builder | | addStatement | public | string | Ajoute une ligne de code | Builder | | addCodeBlock | public | CodeBlock | Ajoute un bloc de code | Builder | | addParameter | public | string, TypeName | Ajoute un paramètre | Builder | | transtypeTo | public | ...string[] | Transtype la méthode | Builder | | return | public | TypeName | Définie une valeur de retour | Builder | | build | public | X | Initialise la construction de la méthode | TSMethod |

CodeBlock

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | new | public static | X | Obtenir le constructeur | Builder | | addStatement | public | string, ...any[] | Ajoute une ligne de code | Builder | | addCodeBlock | public | CodeBlock | Ajoute un bloc de code | Builder | | beginBrace | public | ?string, ...any[] | Insert une accolade ouvrante | Builder | | nextBrace | public | ?string, ...any[] | Insert une accolade ouvrante et fermante | Builder | | endBrace | public | ?boolean | Insert une accolade fermante | Builder | | addComment | public | string | Ajoute un commentaire | Builder | | build | public | X | Initialise le bloc de code | CodeBlock |

TypeName

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | get | public static | string | Définie le nom du type | TypeName | | transtypeTo | public | ...string[] | Transtype le type d'objet | TypeName | | TYPE_VOID | public static | X | Définie le type Void | TypeName | | TYPE_BOOLEAN | public static | X | Définie le type Boolean | TypeName | | TYPE_STRING | public static | X | Définie le type String | TypeName | | TYPE_NUMBER | public static | X | Définie le type Number | TypeName | | TYPE_ANY | public static | X | Définie le type Any | TypeName |

Modifier

| Constantes | | ---------- | | EXPORT | | PUBLIC | | STATIC | | PRIVATE | | ABSTRACT | | PROTECTED | | READONLY |

TSPoet

| Méthodes | Modificateurs | Paramètres | Descriptions | Types | | -------- | ------------- | ---------- | ------------ | ----- | | createFileStream | public static | string, string | Crée un fichier | void | | writeInFile | public static | string, string, TSType | Écrit dans un fichier sans effacer l'ancien contenu | void | | writeFile | public static | string, TSType | Écrit dans un fichier en remplaçant l'ancien contenu | void |

License

Copyright (c) 2020 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.