Introduisez progressivement TypeScript dans votre projet React

Bonjour, Habr!

Récemment, dans le domaine du front-end, la combinaison de React + TypeScript est devenue particulièrement populaire. En conséquence, la pertinence d'une migration compétente de JavaScript vers TypeScript augmente, de préférence en peu de temps. Aujourd'hui, nous aimerions discuter de ce sujet avec vous.



Comment créer et injecter en toute sécurité des composants React TypeScript dans votre projet React JS.

Pourquoi pourriez-vous avoir besoin de migrer de JS vers TS? Il peut y avoir plusieurs raisons à cela, mais ce n'est pas le but. Le fait (hypothétique) est le suivant: vous devez commencer à utiliser TypeScript et vous avez besoin d'un moyen simple de l'implémenter dans votre projet. De plus, tout cela doit être fait d'une manière ou d'une autre, sans violer la structure de tout le code disponible, et convaincre l'équipe de la nécessité d'une telle transition.

Ici, nous allons démontrer une refactorisation étape par étape: comment incorporer des composants React dans une autre base de code, puis utiliser Bit pour les entrer en toute sécurité dans une application JavaScript React fonctionnelle .

Intégrez en toute sécurité des composants TS dans un projet JS à l'aide de Bit




Il existe de nombreuses façons de passer de React JS à React TS. L'essence de cet article est de montrer comment cela se fait progressivement. Une méthode similaire est applicable dans d'autres cas.
L'idée de base est de tirer le meilleur parti de vos composants React + avec Bit pour les isoler les uns des autres dans votre propre environnement de développement Bit. Ensemble, cela vous permet d'assembler des composants TS et de les injecter en toute sécurité dans une application React JS entièrement fonctionnelle.

BitEst un outil open source pour extraire des composants des référentiels Git. Bit vous permet de créer des composants TS en dehors d'un projet écrit en JS, en les allouant à chaque environnement de développement isolé autonome, qui peut fonctionner dans d'autres projets, quelles que soient leurs configurations. Ensuite, vous pouvez simplement versionner et «importer des bits» ces composants dans votre projet JS et ils fonctionneront.

Avec Bit, il y a Bit.dev , un hub distant où vous pouvez stocker ces composants puis les réutiliser. Nous conserverons les composants TS dans Bit.dev, et à partir de là, nous commencerons à les introduire dans notre projet React JS.



Exemple: recherche de composants partagés React dans bit.dev

Exemple d'utilisation


Pour les besoins de cet article, nous analyserons un exemple qui, dans le monde frontal, est comparable au «bonjour monde» classique: nous parlerons d'une application pour la planification de cas.

Ne vous inquiétez pas, je ne vais pas vous dire comment écrire une telle application pour React. Je suppose que vous savez déjà comment procéder et, pour être honnête, le sujet est loin d'être nouveau, alors ignorez.

Mais je vais utiliser cette application comme exemple - vous pouvez à juste titre la bifurquer, ou au moins ouvrir un lien et voir tout son code.



github.com/deleteman/react-todo-demo

Cette base de code comprend les composants suivants:

TodoList: Il s'agit du composant principal affiché sous la forme d'un champ de saisie de texte avec le bouton habituel. Tout est dans le formulaire, après envoi auquel le texte est ajouté à la liste supportée par l'application principale. Le code de ce composant est très simple:

import React, { Component } from 'react'

class TodoList extends Component {
  render() {
    return (
      <div className="todoListMain">
        <div className="header">
          <form onSubmit={this.props.addItem}>
            <input placeholder="Task"
            ref={this.props.inputElement}
            value={this.props.currentItem.text}
            onChange={this.props.handleInput}
             />
            <button type="submit"> Add Task </button>
          </form>
        </div>
      </div>
    )
  }
}

export default TodoList

TodoItems : Un composant de liste très simple utilisé pour afficher une liste interne des éléments ajoutés via le composant précédent. Chacun des éléments est cliquable et après avoir cliqué dessus, il est supprimé de la liste. Le code est également assez simple:

import React, { Component } from 'react'

class TodoItems extends Component {

  createTasks(item) {
    return <li key={item.key} onClick={() => this.props.deleteItem(item.key)}>{item.text}</li>
  }

  render() {
    const todoEntries = this.props.entries || []  
    const listItems = todoEntries.map(this.createTasks.bind(this))    

    return <ul className="theList">{listItems}</ul>
  }
}

export default TodoItems

Dans les deux cas, les méthodes correspondantes sont acceptées en tant que propriétés (accessoires) du composant principal de l'application. Le code complet de ce composant est donné ici.

Je suis d'accord, cette application est très simple, mais, je souligne encore une fois, il pourrait y avoir n'importe quelle application React sur laquelle vous travaillez actuellement - et soudain, vous obtenez la tâche de commencer la migration vers TypeScript. Que faire?

  • Option # 1: Après avoir essuyé les larmes, vous commencez à réécrire toute la base du code source.
  • Option # 2: Renommez tous vos fichiers .js en .ts, configurez les étapes nécessaires dans le processus d'assemblage et lavez-vous les mains.
  • Option n ° 3: vous décidez qu'il est vraiment temps de passer à la migration progressive de tout l'ancien code et d'écrire tout le nouveau code directement sur TypeScript.

Je veux discuter de l'option # 3 plus en détail, mais, en principe, je ne vous refuse pas que dans la même application, vous pouvez coexister des composants écrits à la fois en JavaScript pur et en TypeScript.

Entrez TypeScript


Donc, à titre d'exemple, supposons que nous soyons chargés d'ajouter un bouton à bascule à chaque composant de notre liste de tâches. Après avoir cliqué sur un élément, il doit être changé en arrière-plan.

Rien de surnaturel, mais comme vous vous en souvenez, dans ce cas, nous nous intéressons au processus, pas au code en tant que tel.

Donc, nous n'essaierons pas d'ajouter TypeScript à votre projet personnalisé, afin de ne pas casser accidentellement votre assemblage existant en plusieurs jours, mais de créer un projet complètement nouveau en utilisant TypeScript pur:

$ npx create-react-app ts-components --template typescript

Remarque: pour utiliser npx, vous n'avez besoin que de la nouvelle version de NPM, et elle est incluse dans le processus d'installation dans les versions 5.2.0 et supérieures.

Comme précédemment, dans ce cas, un modèle est créé pour le projet, mais cette fois, nous utilisons TypeScript comme langage de base.

De plus, un simple composant de commutation, adapté à l'insertion dans un autre projet, sans introduire de dépendances supplémentaires. Si vous êtes curieux de savoir comment procéder, lisez l'article suivant sur la façon d'écrire des composants réutilisables .

import React, {useState} from 'react';

interface IActionProps {
	action: (status:boolean) => void,
	buttonText?: string
}

const Toggle = ({action, buttonText="Toggle"}: IActionProps) => {
	const [isSelected, setSelected] = useState(false)
	return (
		<button onClick={() => {
		setSelected(!isSelected)
		action(isSelected)
		}} >{buttonText}</button>
	)	
}

export default Toggle

Maintenant que ce composant est écrit, vous pouvez utiliser Bit (il s'agit d'un outil open source pour versionner et publier des composants individuels) pour extraire ce composant spécifique et le partager afin de pouvoir l'importer ultérieurement à partir de notre projet JavaScript.

//  Bit        
$ yarn global add bit-bin
$ bit init --package-manager yarn//    ( ,       bit.dev)
$ bit login//   
$ bit add src/components/Toggle.tsx //   (    env)
$ bit import bit.envs/compilers/react-typescript --compiler//   
$ bit tag –all

Vous configurez donc votre projet et configurez le nouveau composant Toggle (commutateur) afin qu'il puisse être partagé avec d'autres projets. Mais, avant de pouvoir le faire dans la pratique, vous devez vous connecter à Bit.dev (il s'agit d'un concentrateur de composants - un site avec un registre et une documentation qui complète Bit en tant que plate-forme de publication et d'aperçu des composants).

Une fois connecté, créez simplement une nouvelle collection appelée «toggler», rendez-la publique, puis exécutez la commande suivante dans la fenêtre du terminal:

$ bit export user-name.toggler

Si «nom d'utilisateur» est vraiment votre nom d'utilisateur, le composant sera alors exporté et vous pouvez le voir sur Bit.dev. Il devrait ressembler à ceci:



Notez comment, par défaut, le programme crée un exemple de fichier index.jspour tester le composant. Dans le même temps, le contenu écrit dans ce fichier par défaut peut ne pas être idéal, de sorte que la plate-forme facilite l'ajout de code supplémentaire, afin que les autres comprennent comment utiliser votre composant public dans leur code.

Par exemple, ici, j'ai mis à jour mon exemple de fichier, en ajoutant des explications sur la façon d'utiliser le composant Toggler (n'oubliez pas de cliquer sur le bouton "Enregistrer" lorsque vous avez terminé!):



Voyons maintenant comment importer ce nouveau composant dans votre propre application React basée sur JS.

Importer un composant externe


Bit prend en charge la compilation de votre code TypeScript en JavaScript grâce au compilateur que nous avons ajouté. Cela résout tous nos problèmes, et il ne nous reste plus qu'à ajouter ce composant à votre projet en tant que dépendance.

À toutes fins utiles, j'ai utilisé Yarn ici, mais vous pouvez utiliser NPM avec le même succès, tout ce dont vous avez besoin pour cela:

$ yarn add @bit/your-username.your-collection.your-component

Dans mon cas, ce code se transforme en:

$ yarn add @bit/deleteman.toggler.toggle

Remarque: vous ne pourrez pas installer de composants sans vous connecter (rappelez-vous la partie à propos $ bit loginde ce guide?). Si vous souhaitez installer des composants à partir du registre Bit, vous devez configurer le registre manuellement, comme ceci:

$ npm config set '@bit:registry' https://node.bit.dev

Ainsi, votre composant TypeScript (déjà compilé en JavaScript) sera inclus dans le projet, et vous pourrez vous référer à ce composant de leur code comme suit:

import React, { Component, useState } from 'react'
import Toggle from '@bit/deleteman.toggler.toggle';


const TodoItem = ({text, itemKey}) => {

 	const [iClass, setIClass] = useState("white")

  	const toggleBackground = status => {
  		setIClass(status ? "white" : "black")
  	}

  	const toggleProps = {
  		action: toggleBackground,
  		buttonText: "Select"
  	}

    return <li className={iClass} key={itemKey} >{text}<Toggle {...toggleProps}/></li>
}

export default TodoItem

Faites attention à la ligne 2, où j'importe le composant externe que j'ai l'intention d'utiliser dans le cadre de la déclaration de retour. Rien de compliqué, aucune modification de configuration supplémentaire n'est requise dans votre projet ou ailleurs.
Félicitations, maintenant que vous avez un projet qui utilise à la fois TypeScript et JavaScript, vous pouvez potentiellement le faire pour que vous ne le remarquiez même pas!
Comme je l'ai mentionné ci-dessus, le code de projet complet est publié sur GitHub !

Conclusion


Si vous êtes intéressé par la migration TypeScript, ou si vous voulez simplement l'expérimenter et voir comment cela fonctionne, alors c'est la façon dont il est pratique d'introduire progressivement le langage dans un projet existant, sans risquer de faire tomber l'ensemble du processus d'assemblage.

Faites attention à Bit et regardez Bit.dev, trouvez d'autres composants écrits en JavaScript et TypeScript en même temps pour comprendre comment les autres les écrivent!

All Articles