Tailwind CSS Academy · Lezione

Scalare Tailwind nei monorepo

Condivida un unico tailwind.config.js tra più pacchetti in un monorepo, utilizzi i preset per i token condivisi e gestisca le estensioni specifiche dei workspace.

Lezione 4 di 413 passaggi

Scalare Tailwind nei monorepo è una lezione Tailwind CSS Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Tailwind CSS Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Tailwind CSS Academy include 4 lezioni in totale.

Nozioni di base sui monorepo per Tailwind

Un monorepo è un singolo repository che contiene più pacchetti o applicazioni, gestito con strumenti come Turborepo, Nx o gli workspace di pnpm. Quando più applicazioni di un monorepo usano Tailwind, è importante condividere la configurazione. Senza una configurazione condivisa, ogni applicazione duplica i token dei colori, i font e le configurazioni dei plugin, divergendosi gradualmente fino a rendere incoerente l'interfaccia tra i prodotti.

monorepo/
├── apps/
│   ├── web/          # Next.js marketing site
│   └── dashboard/    # React admin app
├── packages/
│   ├── ui/           # Shared component library
│   └── tailwind-config/  # ← Shared Tailwind config
├── package.json      # Workspace root
└── turbo.json

Creare un pacchetto di configurazione condiviso

Estragga la configurazione di Tailwind in un pacchetto dedicato, generalmente denominato @repo/tailwind-config o @acme/tailwind-config. Questo pacchetto esporta un oggetto di configurazione di base che ogni applicazione utilizzatrice importa ed estende. Il pacchetto condiviso risiede in packages/tailwind-config/ e dispone di un proprio package.json che lo contrassegna come dipendenza interna.

// packages/tailwind-config/package.json
{
  "name": "@acme/tailwind-config",
  "version": "0.0.1",
  "private": true,
  "main": "./tailwind.config.js",
  "devDependencies": {
    "tailwindcss": "^3.4.0"
  }
}

// packages/tailwind-config/tailwind.config.js
/** @type {import('tailwindcss').Config} */
module.exports = {
  theme: {
    extend: {
      colors: {
        brand: { 500: '#3b82f6', 900: '#1e3a8a' },
      },
    },
  },
  plugins: [],
};

Usare la configurazione condivisa

Ogni applicazione importa la configurazione condivisa usando require e la combina o fonde con le sovrascritture specifiche dell'applicazione. Il file tailwind.config.js dell'applicazione aggiunge i propri percorsi content (poiché i percorsi dei contenuti sono sempre specifici dell'applicazione) e qualsiasi estensione propria di quell'applicazione. La configurazione condivisa gestisce tutti i token comuni del tema e i plugin.

// apps/web/tailwind.config.js
const sharedConfig = require('@acme/tailwind-config');

/** @type {import('tailwindcss').Config} */
module.exports = {
  // Merge shared config
  ...sharedConfig,
  // App-specific content paths (NEVER shared — paths differ per app)
  content: [
    './src/**/*.{js,ts,jsx,tsx}',
    './public/**/*.html',
  ],
  theme: {
    ...sharedConfig.theme,
    extend: {
      ...sharedConfig.theme.extend,
      // App-specific extensions
      backgroundImage: {
        'hero-gradient': 'linear-gradient(to bottom, #eff6ff, #ffffff)',
      },
    },
  },
};

Usare i preset di Tailwind

Il sistema di preset di Tailwind è il meccanismo ufficialmente supportato per condividere le configurazioni. Un preset è un oggetto passato all'array presets nella configurazione dell'applicazione utilizzatrice. A differenza della combinazione diretta dell'oggetto di configurazione, i preset vengono fusi in modo intelligente da Tailwind: le estensioni del tema vengono unite in profondità, i plugin vengono concatenati e gli array content vengono combinati senza doverli unire manualmente.

// packages/tailwind-config/tailwind.config.js
/** @type {import('tailwindcss').Config} */
module.exports = {
  theme: {
    extend: {
      colors: { brand: { 500: '#3b82f6' } },
    },
  },
  plugins: [require('@tailwindcss/forms')],
};

// apps/dashboard/tailwind.config.js
module.exports = {
  presets: [require('@acme/tailwind-config')],  // ← official preset
  content: ['./src/**/*.{js,ts,jsx,tsx}'],
  theme: {
    extend: {
      // Deep-merged with preset's theme.extend automatically
      spacing: { 18: '4.5rem' },
    },
  },
};

Percorsi dei contenuti per i pacchetti UI condivisi

Un problema critico nei monorepo: se dispone di una libreria di componenti condivisa packages/ui che esporta componenti con classi Tailwind, l'applicazione utilizzatrice deve includere i file di quel pacchetto nel proprio array content. In caso contrario, il motore JIT non analizza i componenti condivisi e le classi utilizzate al loro interno vengono eliminate dalla build di produzione.

// apps/web/tailwind.config.js
module.exports = {
  presets: [require('@acme/tailwind-config')],
  content: [
    // App's own files
    './src/**/*.{js,ts,jsx,tsx}',
    // ⬇ CRITICAL: include shared UI package files
    '../../packages/ui/src/**/*.{js,ts,jsx,tsx}',
  ],
};

Configurare le dipendenze dello workspace

In un monorepo con workspace pnpm o npm, aggiunga il pacchetto di configurazione condiviso come dipendenza di sviluppo usando il protocollo workspace. In questo modo viene creato un collegamento simbolico al pacchetto locale senza pubblicarlo su npm. Il package.json dell'applicazione utilizzatrice elenca @acme/tailwind-config: workspace:* e gli strumenti di build lo risolvono automaticamente nel pacchetto locale.

// apps/web/package.json
{
  "name": "web",
  "devDependencies": {
    "@acme/tailwind-config": "workspace:*",
    "tailwindcss": "^3.4.0"
  }
}

// Install all workspace packages from the monorepo root:
pnpm install
# or
npm install --workspaces

Caching di Turborepo per le build di Tailwind

In un monorepo Turborepo, configuri la pipeline di turbo.json per memorizzare nella cache gli output della build di Tailwind. Poiché la configurazione condivisa è una dipendenza della build di ogni applicazione, le modifiche a packages/tailwind-config invalidano correttamente la cache della build per tutte le applicazioni utilizzatrici. In questo modo si evita di distribuire CSS obsoleto quando il design system viene aggiornato.

// turbo.json
{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "dist/**", "!.next/cache/**"]
    },
    "type-check": {
      "dependsOn": ["^build"]
    }
  }
}

# Build only what has changed since last run:
npx turbo build
# Turbo caches CSS output and invalidates when tailwind-config changes

Gestire le differenze nei percorsi dei contenuti

I percorsi dei contenuti sono l'unica configurazione che non può essere condivisa: devono essere locali a ogni applicazione. Applicazioni diverse hanno strutture di directory diverse. Eviti la tentazione di inserire i percorsi dei contenuti nella configurazione condivisa: così facendo, potrebbe non individuare alcuni file o analizzarne troppi. La configurazione condivisa dovrebbe esportare solo tema, plugin e preset. I contenuti devono essere sempre definiti localmente nella configurazione di ogni applicazione utilizzatrice.

// packages/tailwind-config/tailwind.config.js
// ⚠ DO NOT include content paths here
module.exports = {
  // content: []  ← Leave this OUT of the shared config
  theme: {
    extend: { colors: { brand: { 500: '#3b82f6' } } },
  },
  plugins: [],
};

// Each app defines its own content:
// apps/web: './src/**/*.{js,ts,jsx,tsx}'
// apps/dashboard: './pages/**/*.tsx', './components/**/*.tsx'

Gestire le versioni della configurazione condivisa

Anche se il pacchetto di configurazione condiviso è privato (non viene mai pubblicato su npm), lo gestisca seguendo una disciplina di versionamento. Incrementi la versione nel package.json a ogni modifica incompatibile, ad esempio la rimozione di un colore, la ridenominazione di un token o la rimozione di un plugin. Gli utilizzatori del preset potranno così fissare una versione e aggiornarla consapevolmente, invece di permettere che modifiche incompatibili si propaghino silenziosamente a tutte le applicazioni contemporaneamente.

// packages/tailwind-config/package.json
{
  "name": "@acme/tailwind-config",
  "version": "1.3.0",   // ← bump on breaking changes
  "private": true,
  "main": "./tailwind.config.js"
}

// apps/dashboard/package.json — pin to a specific version
{
  "devDependencies": {
    "@acme/tailwind-config": "workspace:^1.2.0"  // pin minor version
  }
}

Testare le modifiche alla configurazione condivisa

In questa lezione ha imparato a: creare un pacchetto di configurazione Tailwind condiviso usando il sistema ufficiale dei preset per un merge profondo intelligente, includere i file del pacchetto UI condiviso nei percorsi dei contenuti per impedire l'eliminazione delle classi e trattare le modifiche alla configurazione come modifiche incompatibili tra app, con versionamento e test di regressione visiva. Nel prossimo capitolo progetteremo un sistema di design Tailwind completo per il progetto finale.

# Run all affected builds when tailwind-config changes
npx turbo build --filter='...[origin/main]'
# Turborepo detects which apps depend on the changed package
# and builds only those apps

# Run visual regression on changed apps:
npx playwright test --project=web
npx playwright test --project=dashboard

Integrazione di Storybook nei monorepo

Se usa Storybook nel pacchetto UI condiviso per documentare i componenti, configuri Storybook in modo che utilizzi lo stesso preset Tailwind condiviso. Aggiunga l'add-on Tailwind per Storybook (@storybook/addon-styling-webpack o l'equivalente per il framework) e gli faccia usare la configurazione condivisa. In questo modo, i componenti vengono visualizzati in Storybook con gli stessi token utilizzati nelle app.

// packages/ui/.storybook/main.js
module.exports = {
  addons: ['@storybook/addon-styling-webpack'],
  framework: '@storybook/react-webpack5',
};

// packages/ui/.storybook/preview.js
import '../src/styles/globals.css'; // imports Tailwind

// packages/ui/tailwind.config.js
module.exports = {
  presets: [require('@acme/tailwind-config')],
  content: ['./src/**/*.{js,ts,jsx,tsx}'],
};

Verifica rapida

Verifichi la Sua comprensione dei concetti di Tailwind CSS Mastery affrontati in questa lezione.

Riepilogo della lezione

In this lesson you learned: creating a shared Tailwind config package using the official preset system for intelligent deep-merging, including shared UI package files in content paths to prevent class purging, and treating config changes as cross-app breaking changes with versioning and visual regression tests. Next up we plan a complete Tailwind design system for the capstone project.

Gratis per iniziare

Impara HTML con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
30
Lezioni
120

Domande Frequenti

La lezione «Scalare Tailwind nei monorepo» è gratuita?

Sì — il testo completo di «Scalare Tailwind nei monorepo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Tailwind CSS Academy, passa a CoddyKit PRO. Il corso Tailwind CSS Academy include 4 lezioni in totale.

Cosa imparerò in «Scalare Tailwind nei monorepo»?

Condivida un unico tailwind.config.js tra più pacchetti in un monorepo, utilizzi i preset per i token condivisi e gestisca le estensioni specifiche dei workspace. Eserciti Tailwind CSS Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Tailwind CSS Academy?

Non è richiesta alcuna esperienza precedente. Tailwind CSS Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Scalare Tailwind nei monorepo»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Tailwind CSS Academy?

Sì. Ogni lezione Tailwind CSS Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Organizzazione di file e cartelle
  2. Coesistere con il CSS legacy
  3. CSS Modules e Tailwind
  4. Scalare Tailwind nei monorepo
← Torna a Tailwind CSS Academy