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.

@msay2_recovery/tspoet

TSPoet

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

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]

3.0.6 [Bêta]

3.0.5 [Bêta]

3.0.4

3.0.3

3.0.2

3.0.1

3.0.0

2.1.3

2.1.2

2.0.2

2.0 [Production]

0.0.44 [Bêta]

0.0.1 [Alpha]

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

Exemple

/!\ Avertissement /!\

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

Créations

Classes

Interfaces

Enumérations

Éléments personnalisés

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

Déclaration

Type

Var

Objet

Bloc de code (bonnes pratiques)

Pratiques

Mauvaise pratique

Pratique moins mauvaise

Bonne pratiques

Pour les expressions littérales

Pour les chaînes de caractères

Pour les objets

Importations

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.

Paramètres

Constructeur

Variables

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

Interfaces

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

Annotations

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

Enumération

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

Déclaration

Commentaire

Documentation

Exemple avec le constructeur de méthode.

Génération

Référentiel d'objets

Objets de modélisations principales

TSType

ClassBuilder

EnumBuilder

InterfaceBuilder

CustomElementBuilder

DeclarableBuilder

DeclarableVar

DeclarableType

Objets de modélisations complémentaires

TSProperty

TSVariable

TSObject

TSAnnotation

TSConstant

TSMethod

CodeBlock

TypeName

Modifier

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

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

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

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

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

Weekly Downloads