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.
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.jsonCreare 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 --workspacesCaching 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 changesGestire 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=dashboardIntegrazione 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.
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
- Organizzazione di file e cartelle
- Coesistere con il CSS legacy
- CSS Modules e Tailwind
- Scalare Tailwind nei monorepo