Vue mit Vite, Tailwind CSS und PrimeVue
Setz ein Vue-3-Projekt mit TypeScript und Vite von Hand auf, Datei für Datei, ergänze dann Tailwind CSS und PrimeVue und lass beide Farben und Dark Mode teilen.
Auf dieser Seite
Quest-Ziele
- Ein Vue-3-Projekt mit Vite und TypeScript von Hand aufsetzen
- .vue-Dateien mit vue-tsc auf Typen prüfen
- Tailwind CSS 4 über sein Vite-Plugin einbinden
- PrimeVue mit einem Theme in deiner eigenen Farbe einbinden
- Tailwind und PrimeVue Farben, CSS-Layer und Dark Mode teilen lassen
Ein Projektgenerator setzt Vue mit einem Befehl auf, hinterlässt dir aber ein Dutzend Dateien, die du nicht ausgesucht hast. Von Hand gebaut hat das Projekt nur, was es braucht, und du weißt, wofür jede Datei da ist. Dieses Tutorial baut ein Vue-3-Projekt mit TypeScript und Vite Schritt für Schritt auf, ergänzt Tailwind CSS und dann die Komponentenbibliothek PrimeVue und bringt die beiden zusammen.
Du brauchst Node.js 20.19, 22.12 oder neuer, darauf läuft Vite 8. Die Befehle nutzen npm. Mit pnpm oder Yarn schreibst du pnpm add oder yarn add, wo npm install steht.
Das Projekt
Ein Ordner und eine package.json sind alles, was ein Projekt zu Beginn braucht:
$ mkdir my-app$ cd my-app
{
"name": "my-app",
"private": true,
"type": "module",
"scripts": {
"dev": "vite",
"build": "vue-tsc --build && vite build",
"preview": "vite preview"
}
}"type": "module" lässt Node das JavaScript des Projekts als ES-Module behandeln. Die Skripte sind die drei, die du brauchen wirst: dev startet den Entwicklungsserver, build prüft die Typen und baut das Projekt dann für den Betrieb, und preview liefert diesen Build aus.
Jetzt die Pakete. Vue wird zur Laufzeit gebraucht, alles andere nur beim Entwickeln:
$ npm install vue$ npm install -D vite @vitejs/plugin-vue typescript@~6.0 vue-tsc @vue/tsconfig @tsconfig/node24 @types/node@24
vite ist Entwicklungsserver und Build-Werkzeug, und @vitejs/plugin-vue bringt ihm Single-File-Components bei.
vue-tsc prüft die Typen in
.vue-Dateien, die das normaletscnicht lesen kann.@vue/tsconfig und @tsconfig/node24 sind fertige TypeScript-Einstellungen für den Browser und für Node, und @types/node beschreibt Nodes APIs für
vite.config.ts.
TypeScript
Das Projekt hat Code für zwei Umgebungen: Die App läuft im Browser, und vite.config.ts läuft in Node. Jede bekommt ihre eigene Konfiguration, und eine dritte Datei verbindet sie:
{
"files": [],
"references": [
{ "path": "./tsconfig.node.json" },
{ "path": "./tsconfig.app.json" }
]
}{
"extends": "@vue/tsconfig/tsconfig.dom.json",
"include": ["src/**/*.ts", "src/**/*.vue"],
"compilerOptions": {
"types": ["vite/client"],
"noUncheckedIndexedAccess": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo"
}
}{
"extends": "@tsconfig/node24/tsconfig.json",
"include": ["vite.config.ts"],
"compilerOptions": {
"module": "preserve",
"moduleResolution": "bundler",
"types": ["node"],
"noEmit": true,
"tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo"
}
}vue-tsc --build folgt den Verweisen in tsconfig.json und prüft beide Teile. Für die App gilt:
@vue/tsconfig bringt die strengen Einstellungen mit, die Vue empfiehlt, darunter
strictselbst.vite/clientergänzt Vites Typen, damit TypeScriptimport.meta.envkennt und Importe von CSS und Bildern annimmt.noUncheckedIndexedAccessbehandeltlist[0]als möglicherweiseundefined, was es bei einer leeren Liste auch ist.noUnusedLocalsundnoUnusedParameterszeigen Code, der nichts tut.
Die .tsbuildinfo-Dateien merken sich, was geprüft wurde, damit die nächste Prüfung nur ansieht, was sich geändert hat. Sie landen in node_modules/.tmp, aus dem Weg.
Vite und der Einstiegspunkt
Vite braucht vorerst ein Plugin:
import vue from '@vitejs/plugin-vue';
import { defineConfig } from 'vite';
export default defineConfig({
plugins: [vue()],
});Die Seite selbst ist index.html im Hauptordner des Projekts. Vite beginnt dort und folgt dem Script-Tag zu src/main.ts:
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>My app</title>
</head>
<body>
<div id="app"></div>
<script type="module" src="/src/main.ts"></script>
</body>
</html>import { createApp } from 'vue';
import App from './App.vue';
createApp(App).mount('#app');<script setup lang="ts">
const name = 'app';
</script>
<template>
<h1>Hello {{ name }}</h1>
</template>Starte den Entwicklungsserver:
$ npm run dev VITE v8.3.5 ready in 312 ms ➜ Local: http://localhost:5173/ ➜ Network: use --host to expose ➜ press h + enter to show help
Öffne http://localhost:5173/, und „Hello app“ ist da. Lass den Server laufen: Ab jetzt erscheint jede Änderung im Browser, sobald du speicherst.
Tailwind CSS
Tailwind 4 kommt als Vite-Plugin und braucht weder eine tailwind.config.js noch PostCSS:
$ npm install -D tailwindcss @tailwindcss/viteimport tailwindcss from '@tailwindcss/vite';
import vue from '@vitejs/plugin-vue';
import { defineConfig } from 'vite';
export default defineConfig({
plugins: [vue(), tailwindcss()],
});Ein Stylesheet importiert Tailwind. Seine Einstellungen, etwa eigene Farben, kommen bei Bedarf mit @theme in dieselbe Datei:
@import 'tailwindcss';main.ts importiert das Stylesheet vor allem anderen:
import './assets/main.css';
import { createApp } from 'vue';
import App from './App.vue';
createApp(App).mount('#app');Um zu sehen, dass es funktioniert, bekommt die Überschrift ein paar Klassen:
<script setup lang="ts">
const name = 'app';
</script>
<template>
<h1 class="p-8 text-3xl font-bold text-orange-500">Hello {{ name }}</h1>
</template>Vite bemerkt die geänderte Konfiguration und startet von selbst neu. Die Überschrift wird groß, fett und orange.
PrimeVue
PrimeVue bringt fertige Komponenten mit: Buttons, Tabellen, Dialoge, Datumsauswahl und rund 80 weitere, mit Themes, die du anpassen kannst.
$ npm install primevue@4 @primeuix/themes@2$ npm install -D tailwindcss-primeui
@primeuix/themes enthält PrimeVues Themes, und tailwindcss-primeui macht PrimeVues Farben als Tailwind-Klassen verfügbar. Es kommt ins Stylesheet, zusammen mit einer Dark-Variante, die zu PrimeVues passt:
@import 'tailwindcss';
@import 'tailwindcss-primeui';
/* dark: applies inside an element with the class dark, the same selector PrimeVue uses */
@custom-variant dark (&:where(.dark, .dark *));Tailwinds dark:-Klassen folgen normalerweise der Systemeinstellung. Mit der eigenen Variante gelten sie stattdessen innerhalb eines Elements mit der Klasse dark, sodass ein Schalter auf der Seite den Dark Mode an- und ausschalten kann.
PrimeVues eigene Einrichtung kommt in eine eigene Datei, damit main.ts kurz bleibt:
import { definePreset } from '@primeuix/themes';
import Aura from '@primeuix/themes/aura';
import PrimeVue from 'primevue/config';
import ToastService from 'primevue/toastservice';
import type { App } from 'vue';
// Aura, with orange instead of emerald as the primary color
const Preset = definePreset(Aura, {
semantic: {
primary: {
50: '{orange.50}',
100: '{orange.100}',
200: '{orange.200}',
300: '{orange.300}',
400: '{orange.400}',
500: '{orange.500}',
600: '{orange.600}',
700: '{orange.700}',
800: '{orange.800}',
900: '{orange.900}',
950: '{orange.950}',
},
},
});
export function installPrimeVue(app: App) {
app.use(PrimeVue, {
ripple: true,
theme: {
preset: Preset,
options: {
darkModeSelector: '.dark',
// Puts PrimeVue's styles between Tailwind's base and utilities,
// so a utility class on a component wins
cssLayer: {
name: 'primevue',
order: 'theme, base, primevue',
},
},
},
});
// For toast messages, through useToast()
app.use(ToastService);
}definePresetnimmt das Theme Aura und ersetzt seine Primärfarbe.{orange.500}verweist auf eine Farbe aus der Palette des Themes, damit alle elf Abstufungen zusammenpassen.darkModeSelector: '.dark'ist derselbe Selektor wie die eigene Variante im Stylesheet: Eine Klasse an<html>schaltet beide.cssLayerlegt PrimeVues Styles in einen eigenen CSS-Layer, zwischen Tailwinds Grundstile und seine Utilities. Eine Tailwind-Klasse an einer PrimeVue-Komponente gewinnt deshalb, ohne!important.rippleschaltet den Welleneffekt beim Klick auf einen Button ein, und derToastServicelässt jede Komponente Toast-Meldungen anzeigen.
main.ts ruft das auf, bevor es die App einhängt:
import './assets/main.css';
import { createApp } from 'vue';
import App from './App.vue';
import { installPrimeVue } from './primevue';
const app = createApp(App);
installPrimeVue(app);
app.mount('#app');Und App.vue probiert alles aus: zwei PrimeVue-Buttons, einen Toast und einen Dark-Mode-Schalter, mit Tailwind-Klassen dazwischen:
<script setup lang="ts">
import Button from 'primevue/button';
import Toast from 'primevue/toast';
import { useToast } from 'primevue/usetoast';
const toast = useToast();
function greet() {
toast.add({ severity: 'success', summary: 'Hello', detail: 'PrimeVue works.', life: 3000 });
}
function toggleDarkMode() {
document.documentElement.classList.toggle('dark');
}
</script>
<template>
<Toast />
<main class="min-h-screen bg-surface-0 p-8 text-surface-900 dark:bg-surface-950 dark:text-surface-0">
<h1 class="text-3xl font-bold text-primary">Hello app</h1>
<p class="mt-2 text-muted-color">Tailwind and PrimeVue share their colors and dark mode.</p>
<div class="mt-6 flex gap-2">
<Button label="Say hello" @click="greet" />
<Button label="Dark mode" severity="secondary" class="px-6" @click="toggleDarkMode" />
</div>
</main>
</template>Komponenten werden einzeln über ihren eigenen Pfad importiert, etwa primevue/button, damit der Build nur die enthält, die du nutzt. Im Browser:
Die Überschrift und der erste Button sind orange.
text-primary,text-muted-colorund diesurface-Farben kommen austailwindcss-primeuiund sind die Farben des Themes.Der zweite Button ist breiter als der erste: Tailwinds
px-6schlägt PrimeVues eigenes Padding, dank der Reihenfolge der Layer.Say hello zeigt oben rechts einen Toast.
Dark mode setzt die Klasse
darkan<html>. Die Seite wird über Tailwindsdark:-Klassen dunkel, und PrimeVues Buttons wechseln gleichzeitig zu ihren dunklen Farben.
Für den Betrieb bauen
$ npm run build$ npm run preview
npm run build prüft die Typen und schreibt die fertige Seite nach dist, und npm run preview liefert sie zum Ausprobieren unter http://localhost:4173/ aus. Das Projekt sieht jetzt so aus, neben node_modules:
my-app/
├── index.html
├── package.json
├── tsconfig.json
├── tsconfig.app.json
├── tsconfig.node.json
├── vite.config.ts
└── src/
├── App.vue
├── main.ts
├── primevue.ts
└── assets/
└── main.cssMit PrimeVue 5
Mit einem Lizenzschlüssel für PrimeVue 5 installierst du stattdessen primevue@5 und @primeuix/themes@3 und ergänzt den Schlüssel in den Optionen in src/primevue.ts. Alles andere bleibt, wie es ist:
app.use(PrimeVue, {
license: 'your license key',
theme: {
// ...as above
},
});Von hier aus ist Deine ersten Vue-3-Composables ein guter nächster Schritt.
Kommentare
Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.
Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.