0Pricing
TypeScript Academy · Leçon

Publier des packages avec leurs types

Publiez des bibliothèques avec des typages de premier ordre : générez les .d.ts avec tsc, indiquez-les dans package.json, gérez les exportations ESM/CJS et testez avant la publication.

Publier des packages avec leurs types est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 2. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 2 leçons au total.

Introduction

Objectif : publier un paquet doté de typages solides. Vous allez générer des fichiers .d.ts, configurer correctement package.json, prendre en charge ESM/CJS via exports et vérifier le tout avec tsc --noEmit dans une application exemple.

  • Générer des déclarations
  • Renseigner types (ou les exports de chaque point d’entrée)
  • Vérifier avant la publication

Générer des déclarations

Activez declaration pour générer des fichiers .d.ts. Utilisez une configuration de compilation dédiée afin de conserver le tsconfig de l’application strict et propre.

// tsconfig.build.json
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "declaration": true,
    "emitDeclarationOnly": false,
    "outDir": "dist",
    "rootDir": "src",
    "stripInternal": true
  },
  "include": ["src/**/*"]
}

Entrées types/exports de package.json

Faites pointer types vers la déclaration racine. Pour les exportations de sous-chemins, incluez une entrée types afin que les éditeurs résolvent le fichier .d.ts de chaque module.

// package.json
{
  "name": "@acme/widgets",
  "version": "1.0.0",
  "type": "module",
  "main": "./dist/index.cjs",
  "module": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "import": "./dist/index.js",
      "require": "./dist/index.cjs"
    },
    "./utils": {
      "types": "./dist/utils.d.ts",
      "import": "./dist/utils.js",
      "require": "./dist/utils.cjs"
    }
  }
}

Code source et .d.ts

Assurez-vous que votre API publique est correctement typée. Les déclarations reproduisent les signatures du code source afin que les utilisateurs bénéficient de l’autocomplétion et de la vérification.

// src/index.ts
export interface Widget { id: string; name: string }
export function greet(w: Widget): string { return `Hello, ${w.name}` }

// dist/index.d.ts (emitted)
export interface Widget { id: string; name: string }
export declare function greet(w: Widget): string

Vérifier dans un projet utilisateur

Avant la publication, vérifiez le paquet dans un petit projet utilisateur avec tsc --noEmit. Les utilisations invalides doivent produire les erreurs attendues.

// consumer/tsconfig.json
{
  "compilerOptions": { "strict": true, "target": "ES2020", "module": "ESNext" },
  "include": ["./src"]
}

// consumer/src/app.ts
import { greet } from "@acme/widgets"

// Type checks in the consumer
console.log(greet({ id: "w1", name: "Ada" }))
// @ts-expect-error: missing name
// console.log(greet({ id: "w1" }))

Conseils et pièges

Conseils :

  • Privilégiez les exports de sous-chemins avec des types pour chaque point d’entrée.
  • Gardez les types internes non exportés ou marquez-les avec @internal.
  • Utilisez un script prepare pour effectuer la compilation avant npm publish.

Vérification de la publication des types

Vérification rapide : quelle est la configuration minimale correcte pour exposer les types ?

Récapitulatif

Récapitulatif : générez les déclarations avec tsc, configurez package.json (types/exports) et vérifiez le résultat dans une application utilisateur avant la publication.

Questions Fréquemment Posées

La leçon « Publier des packages avec leurs types » est-elle gratuite ?

Oui — le texte complet de « Publier des packages avec leurs types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 2 leçons au total.

Qu'est-ce que j'apprendrai dans « Publier des packages avec leurs types » ?

Publiez des bibliothèques avec des typages de premier ordre : générez les .d.ts avec tsc, indiquez-les dans package.json, gérez les exportations ESM/CJS et testez avant la publication. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 2.

Combien de temps prend la leçon « Publier des packages avec leurs types » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Bases de .d.ts ; export type ou export
  2. Publier des packages avec leurs types
← Retour à TypeScript Academy