From 3d989e93c05023d9a41924adeb852ecf917c20ec Mon Sep 17 00:00:00 2001 From: trueberryless Date: Sun, 8 Dec 2024 14:46:49 +0100 Subject: [PATCH 1/6] first part --- src/content/docs/de/guides/upgrade-to/v5.mdx | 1017 ++++++++++++++++++ 1 file changed, 1017 insertions(+) create mode 100644 src/content/docs/de/guides/upgrade-to/v5.mdx diff --git a/src/content/docs/de/guides/upgrade-to/v5.mdx b/src/content/docs/de/guides/upgrade-to/v5.mdx new file mode 100644 index 0000000000000..b73a98dfa7eff --- /dev/null +++ b/src/content/docs/de/guides/upgrade-to/v5.mdx @@ -0,0 +1,1017 @@ +--- +title: Aktualisierung auf Astro v5 +description: So aktualisierst du dein Projekt auf Astro v5.0. +sidebar: + label: v5.0 +i18nReady: true +--- + +import PackageManagerTabs from '~/components/tabs/PackageManagerTabs.astro'; +import { Steps } from '@astrojs/starlight/components'; +import ReadMore from '~/components/ReadMore.astro'; +import SourcePR from '~/components/SourcePR.astro'; + +Dieser Leitfaden hilft dir bei der Migration von Astro v4 auf Astro v5. + +Du musst zuerst ein älteres Projekt auf v4 aktualisieren? Siehe unseren [older migration guide](/de/guides/upgrade-to/v4/). + +Willst du die v4-Dokumente sehen? Besuche diese [ältere Version der Doku-Site (ungepflegter v4.16 Snapshot)](https://v4.docs.astro.build/). + +## Astro aktualisieren + +Aktualisiere die Version von Astro in deinem Projekt mit deinem Paketmanager auf die neueste Version: + + + + ```shell + # Astro und offiziellen Integrationen zusammen aktualisieren + npx @astrojs/upgrade + ``` + + + ```shell + # Astro und offiziellen Integrationen zusammen aktualisieren + pnpm dlx @astrojs/upgrade + ``` + + + ```shell + # Astro und offiziellen Integrationen zusammen aktualisieren + yarn dlx @astrojs/upgrade + ``` + + + +Du kannst deine Astro-Integrationen auch [manuell aktualisieren](/de/guides/integrations-guide/#manualle-aktualisierung), falls nötig, und du musst eventuell auch andere Abhängigkeiten in deinem Projekt aktualisieren. + +:::note[Muss ich fortfahren?] +Nach dem Upgrade von Astro musst du vielleicht gar keine Änderungen an deinem Projekt vornehmen! + +Wenn du jedoch Fehler oder ein unerwartetes Verhalten bemerkst, überprüfe bitte unten, was sich geändert hat und was in deinem Projekt aktualisiert werden muss. +::: + +Astro v5.0 enthält [potenziell brechende Änderungen](#bahnbrechende-änderungen) sowie die Entfernung und Veraltung einiger Funktionen. + +Wenn dein Projekt nach dem Upgrade auf Version 5.0 nicht wie erwartet funktioniert, findest du in diesem Leitfaden einen Überblick über alle wichtigen Änderungen und Anweisungen, wie du deine Codebasis aktualisieren kannst. + +Die vollständigen Versionshinweise findest du im [Astro-Änderungsprotokoll](https://github.com/withastro/astro/blob/main/packages/astro/CHANGELOG.md). + +## Abhängigkeits-Aktualisierungen + +Jede größere Aktualisierung der Astro-Abhängigkeiten kann zu Änderungen in deinem Projekt führen. + +### Vite 6.0 + +Astro v5.0 wird auf Vite v6.0 als Entwicklungsserver und Produktions-Bundler aktualisiert. + +#### Was soll ich machen? + +Wenn du Vite-spezifische Plugins, Konfigurationen oder APIs verwendest, prüfe den [Vite-Migrationsleitfaden](https://vite.dev/guide/migration.html) auf die entsprechenden Änderungen und aktualisiere dein Projekt bei Bedarf. + +### `@astrojs/mdx` + + + +In Astro v4.x führte Astro eine interne JSX-Verarbeitung für die `@astrojs/mdx`-Integration durch. + +Astro v5.0 überträgt die Verantwortung für die Verarbeitung und Darstellung von JSX und MDX direkt an das Paket `@astrojs/mdx`. Das bedeutet, dass Astro 5.0 nicht mehr mit älteren Versionen der MDX-Integration kompatibel ist. + +#### Was soll ich machen? + +Wenn dein Projekt `.mdx`-Dateien enthält, musst du `@astrojs/mdx` auf die neueste Version (v4.0.0) aktualisieren, damit dein JSX von der Integration richtig verarbeitet werden kann. + +Wenn du einen MDX-Server-Renderer mit der experimentellen [Astro Container API](/de/reference/container-reference/) verwendest, musst du den Import aktualisieren, um den neuen Speicherort zu berücksichtigen: + +```ts del={1} ins={2} +import mdxRenderer from "astro/jsx/server.js"; +import mdxRenderer from "@astrojs/mdx/server.js"; +``` + +Erfahre mehr über [MDX in deinem Projekt verwenden](/de/guides/integrations-guide/mdx/). + +## Legacy + +Die folgenden Funktionen gelten jetzt als Legacy-Funktionen. Sie sollten normal funktionieren, werden aber nicht mehr empfohlen und befinden sich im Wartungsmodus. Sie werden in Zukunft nicht mehr verbessert und die Dokumentation wird nicht mehr aktualisiert. Diese Funktionen werden irgendwann veraltet sein und dann ganz entfernt werden. + +### Legacy: v2.0 Content Collections API + +In Astro 4.x wurden Inhaltssammlungen mit [der in Astro v2.0 eingeführten Inhaltssammlungs-API](https://astro.build/blog/introducing-content-collections/) definiert, abgefragt und gerendert. + +Mit Astro 5.0 wird eine neue Version von Inhaltssammlungen eingeführt, die die Content Layer API nutzt und mehrere Leistungsverbesserungen und zusätzliche Funktionen bietet. Während alte (Legacy) und neue (Content Layer API) Sammlungen in dieser Version weiterhin zusammen existieren können, gibt es potenziell einschneidende Änderungen für bestehende Legacy-Sammlungen. + +#### Was soll ich machen? + +Wir empfehlen, [bestehende Sammlungen auf die neue Content Layer API umzustellen](#bestehende-sammlungen-aktualisieren), sobald du dazu in der Lage bist, und neue Sammlungen mit der Content Layer API zu erstellen. + +Wenn du nicht in der Lage bist, deine Sammlungen umzuwandeln, dann sieh bitte in den [Änderungen an Legacy-Sammlungen](#änderungen-an-den-alten-sammlungen-content-and-data) nach, ob deine bestehenden Sammlungen betroffen sind und aktualisiert werden müssen. + +Wenn du zu diesem Zeitpunkt keine Änderungen an deinen Sammlungen vornehmen kannst, kannst du [die Option `legacy.collections` aktivieren](#aktivieren-die-legacycollections-option), das es dir ermöglicht, deine Sammlungen in ihrem aktuellen Zustand zu belassen, bis die Legacy-Option nicht mehr unterstützt wird. + +Erfahre mehr über die aktualisierten [Inhaltssammlungen](/de/guides/content-collections/). + +##### Bestehende Sammlungen aktualisieren + +Im Folgenden findest du Anweisungen, wie du eine bestehende Inhaltssammlung (`type: 'content'` oder `type: 'data'`) aktualisieren kannst, um die Content Layer API zu nutzen. + +
+Schritt-für-Schritt-Anleitung zur Aktualisierung einer Sammlung + + + +1. **Verschiebe die Content-Konfigurationsdatei**. Diese Datei befindet sich nicht mehr im Ordner `src/content/`. Die Datei sollte jetzt unter `src/content.config.ts` zu finden sein. + +2. **Bearbeite die Sammlungsdefinition**. Deine aktualisierte Sammlung erfordert einen `loader`, und die Option, einen Sammlungs-`type` auszuwählen, ist nicht mehr verfügbar. + + ```ts ins={3,8} del={7} + // src/content.config.ts + import { defineCollection, z } from 'astro:content'; + import { glob } from 'astro/loaders'; + + const blog = defineCollection({ + // Für die Inhaltsebene wird kein `type` mehr definiert + type: 'content', + loader: glob({ pattern: '**/[^_]*.md', base: "./src/data/blog" }), + schema: z.object({ + title: z.string(), + description: z.string(), + pubDate: z.coerce.date(), + updatedDate: z.coerce.date().optional(), + }), + }); + ``` + +3. **Ändere die Referenzen von `slug` zu `id`**. Sammlungen der Inhaltsebene haben kein reserviertes Feld `slug`. Stattdessen haben alle aktualisierten Sammlungen eine `id`. Möglicherweise musst du auch die Namen der dynamischen Routingdateien aktualisieren, damit sie mit einem geänderten getStaticPaths()-Parameter übereinstimmen: + + ```astro ins={7} del={6} + // src/pages/[id].astro + --- + export async function getStaticPaths() { + const posts = await getCollection('blog'); + return posts.map((post) => ({ + params: { slug: post.slug }, + params: { id: post.id }, + props: post, + })); + } + --- + ``` + +4. **Umstellung auf die neue Funktion `render()`**. Einträge haben keine `render()` Methode mehr, da sie jetzt serialisierbare einfache Objekte sind. Importiere stattdessen die Funktion `render()` von `astro:content`. + + ```astro title="src/pages/index.astro" ins=", render" del={6} ins={7} + --- + import { getEntry, render } from 'astro:content'; + + const post = await getEntry('blog', params.slug); + + const { Content, headings } = await post.render(); + const { Content, headings } = await render(post); + --- + + ``` + + +
+ +##### Änderungen an den alten Sammlungen `content` und `data` + + + +Standardmäßig werden Sammlungen, die die alte Eigenschaft `type` (`content` oder `data`) verwenden und keinen `loader` definieren, jetzt unter der Haube mit dem eingebauten `glob()`-Loader der Content-Layer-API implementiert, mit zusätzlicher Abwärtskompatibilitätsbehandlung. + +Außerdem besteht eine vorübergehende Abwärtskompatibilität, wenn die Content-Config-Datei an ihrem ursprünglichen Speicherort `src/content/config.ts` bleibt. + +Diese Abwärtskompatibilitäts-Implementierung ist in der Lage, die meisten Funktionen der alten Sammlungen zu emulieren und ermöglicht es, dass viele alte Sammlungen weiterhin funktionieren, ohne dass du deinen Code aktualisieren musst. Es gibt jedoch **einige Unterschiede und Einschränkungen, die zu Änderungen an bestehenden Sammlungen führen können**: + + - In früheren Versionen von Astro wurden Sammlungen für alle Ordner in `src/content/` erzeugt, auch wenn sie nicht in `src/content/config.ts` definiert waren. Dieses Verhalten ist jetzt veraltet und Sammlungen sollten immer in der Datei `src/content.config.ts` definiert werden. Für bestehende Sammlungen kannst du einfach leere Deklarationen verwenden (z.B. `const blog = defineCollection({})`) und Astro wird deine alte Sammlung implizit so definieren, dass sie mit dem neuen Ladeverhalten kompatibel ist. + - Das spezielle Feld `layout` wird in Markdown-Sammlungseinträgen nicht unterstützt. Diese Eigenschaft ist nur für eigenständige Seitendateien gedacht, die sich in `src/pages/` befinden und wahrscheinlich nicht in deinen Sammlungseinträgen vorkommen. Wenn du diese Eigenschaft verwendet hast, musst du jetzt dynamische Routen erstellen, die dein Seitenstyling enthalten. + - Die Sortierreihenfolge der erzeugten Sammlungen ist nicht deterministisch und plattformabhängig. Das heißt, wenn du `getCollection()` aufrufst, kann die Reihenfolge, in der die Einträge zurückgegeben werden, anders sein als vorher. Wenn du eine bestimmte Reihenfolge brauchst, musst du die Sammlungseinträge selbst sortieren. + - `image().refine()` wird nicht unterstützt. Wenn du die Eigenschaften eines Bildes validieren musst, musst du dies zur Laufzeit in deiner Seite oder Komponente tun. + - Das Argument `key` von `getEntry(collection, key)` wird als `string` typisiert, anstatt Typen für jeden Eintrag zu haben. + - Wenn du bisher `getEntry(collection, key)` mit einem statischen String als Schlüssel aufgerufen hast, war der Rückgabetyp nicht nullbar. Der Typ enthält jetzt `undefined`, sodass du prüfen musst, ob der Eintrag definiert ist, bevor du das Ergebnis verwendest, sonst gibt es Typfehler. + +##### Aktivieren der `legacy.collections`-Option + + + +Wenn du noch nicht bereit bist, deine bestehenden Sammlungen zu aktualisieren, kannst du die Option [`legacy.collections`](/de/reference/legacy-flags/) aktivieren und deine bestehenden Sammlungen funktionieren weiterhin wie bisher. + +## Veraltet + +Die folgenden veralteten Funktionen werden nicht mehr unterstützt und sind nicht mehr dokumentiert. Bitte aktualisiere dein Projekt entsprechend. + +Einige veraltete Funktionen können vorübergehend weiter funktionieren, bis sie vollständig entfernt werden. Andere haben möglicherweise keine Wirkung mehr oder geben einen Fehler aus, der dich auffordert, deinen Code zu aktualisieren. + +### Veraltet: `Astro.glob()` + + + +In Astro v4.x konntest du `Astro.glob()` in deinen `.astro`-Komponenten verwenden, um mehrere Dateien in deinem Projekt abzufragen. Dies hatte einige Einschränkungen (wo es verwendet werden konnte, Leistung usw.), und die Verwendung von Abfragefunktionen aus der Content Collections API oder Vites eigenem `import.meta.glob()` bot oft mehr Funktion und Flexibilität. + +Astro 5.0 veraltet `Astro.glob()` zugunsten von `getCollection()` zur Abfrage deiner Sammlungen und `import.meta.glob()` zur Abfrage anderer Quelldateien in deinem Projekt. + +#### Was soll ich machen? + +Ersetze alle Verwendungen von `Astro.glob()` durch `import.meta.glob()`. Beachte, dass `import.meta.glob()` nicht mehr ein `Promise` zurückgibt, also musst du deinen Code eventuell entsprechend anpassen. Deine [Glob-Muster](/de/guides/imports/#glob-muster) solltest du nicht aktualisieren müssen. + +```astro title="src/pages/blog.astro" del={2} ins={3} +--- +const posts = await Astro.glob('./posts/*.md'); +const posts = Object.values(import.meta.glob('./posts/*.md', { eager: true })); +--- + +{posts.map((post) =>
  • {post.frontmatter.title}
    • )} +``` + +Verwende ggf. [Inhaltssammlungen](/de/guides/content-collections/), um deine Inhalte zu organisieren, die über eigene, neuere und leistungsfähigere Abfragefunktionen verfügen. + +Du kannst auch Glob-Pakete von NPM verwenden, wie z.B. [`fast-glob`](https://www.npmjs.com/package/fast-glob). + +Erfahre mehr über [Importieren von Dateien mit `import.meta.glob`](/de/guides/imports/#importmetaglob). + +### Veraltet: `functionPerRoute` (Adapter API) + + + +In Astro v4.x konntest du für jede im Projekt definierte Route eine eigene Datei erstellen, die dein Verzeichnis `src/pages/` im Build-Ordner widerspiegelt. Standardmäßig gab Astro eine einzige Datei `entry.mjs` aus, die für die Ausgabe der gerenderten Seite bei jeder Anfrage verantwortlich war. + +Astro v5.0 entfernt die Option, das Standardverhalten zu deaktivieren. Dieses Verhalten ist jetzt Standard und nicht mehr konfigurierbar. + +Entferne die Eigenschaft `functionPerRoute` aus deiner `adapterFeatures` Konfiguration. Sie ist nicht mehr verfügbar. + +```js title="my-adapter.mjs" del={10} +export default function createIntegration() { + return { + name: '@matthewp/my-adapter', + hooks: { + 'astro:config:done': ({ setAdapter }) => { + setAdapter({ + name: '@matthewp/my-adapter', + serverEntrypoint: '@matthewp/my-adapter/server.js', + adapterFeatures: { + functionPerRoute: true + } + }); + }, + }, + }; +} +``` + +Erfahre mehr über [die Adapter-API](/de/reference/adapter-reference/) zur Erstellung von Adapter-Integrationen. + +### Veraltet: `routes` on `astro:build:done` hook (Integration API) + + + +In Astro v4.x griffen die Integrationen auf Routen über den Hook `astro:build:done` zu. + +Astro v5.0 veraltet das Array `routes`, das an diesen Hook übergeben wird. Stattdessen gibt es einen neuen `astro:routes:resolved`-Hook, der vor `astro:config:done` ausgeführt wird und immer dann, wenn sich eine Route in der Entwicklung ändert. Er hat dieselben Eigenschaften wie die veraltete `routes`-Liste, mit Ausnahme von `distURL`, die nur während des Builds verfügbar ist. + +#### Was soll ich machen? + +Entferne jede Instanz von `routes`, die an `astro:build:done` übergeben wurde und ersetze sie durch den neuen `astro:routes:resolved` Hook. Greife auf `distURL` in der neuen Karte `assets` zu: + +```js title="my-integration.mjs" ins={2,6-8,11,13-18} del={10} +const integration = () => { + let routes + return { + name: 'my-integration', + hooks: { + 'astro:routes:resolved': (params) => { + routes = params.routes + }, + 'astro:build:done': ({ + routes + assets + }) => { + for (const route of routes) { + const distURL = assets.get(route.pattern) + if (distURL) { + Object.assign(route, { distURL }) + } + } + console.log(routes) + } + } + } +} +``` + +Learn more about [the Integration API `astro:routes:resolved` hook](/de/reference/integrations-reference/#astroroutesresolved) for building integrations. + +## Entfernt + +Die folgenden Funktionen wurden vollständig aus der Codebasis entfernt und können nicht mehr verwendet werden. Einige dieser Funktionen können in deinem Projekt auch nach der Ausmusterung noch funktionieren. Andere haben möglicherweise keine Wirkung mehr gezeigt. + +Projekte, die diese entfernten Funktionen enthalten, können nicht mehr gebaut werden, und es gibt keine unterstützende Dokumentation mehr, die dich auffordert, diese Funktionen zu entfernen. + +### Entfernt: Die Lit-Integration + + + +In Astro v4.x war [Lit](https://lit.dev/) eine Kernbibliothek, die über das Paket `@astrojs/lit` gepflegt wurde. + +Astro v5.0 entfernt die Integration und es wird keine weiteren Updates für die Kompatibilität mit 5.x und höher erhalten. + +#### Was soll ich machen? + +Du kannst Lit weiterhin für Client-Komponenten verwenden, indem du ein clientseitiges Script-Tag hinzufügst. Zum Beispiel: + +```astro + + +... +``` + +Wenn du selbst eine Lit-Integration pflegen möchtest, kannst du die [letzte veröffentlichte Version von `@astrojs/lit`](https://github.com/withastro/astro/tree/astro%404.13.0/packages/integrations/lit) als Ausgangspunkt verwenden und die relevanten Pakete aktualisieren. + +Erfahre mehr über [Astros offizielle Integrationen](/de/guides/integrations-guide/). + +### Entfernt: `hybrid` Rendering-Modus + + + + +Astro v4.x bot drei `output`-Rendering-Modi: `'static'`, `'hybrid'` und `'server'`. + +Astro v5.0 merget die `output: 'hybrid'` und `output: 'static'`-Konfigurationen zu einer einzigen Konfiguration (jetzt `'static'` genannt) zusammen, die genauso funktioniert wie die bisherige Hybrid-Option. + +Es ist nicht mehr notwendig, in deiner Astro-Konfiguration `output: 'hybrid'` in deiner Astro-Konfiguration anzugeben, um server-gerenderte Seiten zu verwenden. Die neue Option `output: 'static'` hat diese Funktion bereits integriert. + +Astro ermöglicht es dir jetzt automatisch, das Prerendering in deiner statischen Website zu deaktivieren, ohne dass du deine Ausgabekonfiguration ändern musst. Jede Seitenroute oder jeder Endpunkt kann `export const prerender = false` enthalten, um bei Bedarf vom Server gerendert zu werden, während der Rest deiner Website statisch generiert wird. + +#### Was soll ich machen? + +Wenn dein Projekt Hybrid-Rendering verwendet hat, musst du jetzt die Option `output: 'hybrid'` aus deiner Astro-Konfiguration entfernen, da sie nicht mehr existiert. Es sind jedoch keine weiteren Änderungen an deinem Projekt erforderlich, und du solltest keine Änderungen vornehmen müssen. Das frühere `'hybrid'`-Verhalten ist jetzt die Standardeinstellung unter dem neuen Namen `'static'`. + +```js title="astro.config.mjs" del={4} +import { defineConfig } from "astro/config"; + +export default defineConfig({ + output: 'hybrid', +}); +``` + +Wenn du die Option `output: 'static'` (Standard) verwendet hast, kannst du diese Option weiterhin nutzen. Standardmäßig werden alle deine Seiten weiterhin vorgerendert und du hast eine komplett statische Website. Du solltest keine Änderungen an deinem Projekt vornehmen müssen. + +Für den Einsatz eines Astro-Projekts mit serverseitig gerenderten Seiten ist immer noch ein Adapter erforderlich, unabhängig davon, welchen `output`-Modus dein Projekt verwendet. Wenn du keinen Adapter einbindest, erhältst du eine Warnung während der Entwicklung und einen Fehler beim Build. + +Erfahre mehr über [On-Demand-Rendering in Astro](/de/guides/on-demand-rendering/). + +### Entfernt: Squoosh-Image-Dienst + + + +In Astro 4.x konntest du `image.service: squooshImageService()` so konfigurieren, dass Squoosh anstelle von Sharp für die Umwandlung deiner Bilder verwendet wurde. Die zugrunde liegende Bibliothek `libsquoosh` wird jedoch nicht mehr gepflegt und hat Speicher- und Leistungsprobleme. + +Mit Astro 5.0 wird der Bildoptimierungsdienst Squoosh komplett entfernt. + +#### Was soll ich machen? + +Um zum eingebauten Sharp-Bilddienst zu wechseln, entferne den Import von `squooshImageService` aus deiner Astro-Konfiguration. Standardmäßig verwendest du Sharp für `astro:assets`. + +```ts title="astro.config.mjs" del={1, 5-7} +import { squooshImageService } from "astro/config"; +import { defineConfig } from "astro/config"; + +export default defineConfig({ + image: { + service: squooshImageService() + } +}); +``` + +Wenn du einen strengen Paketmanager wie `pnpm` verwendest, musst du möglicherweise das Paket `sharp` manuell installieren, um den Sharp-Bilddienst zu nutzen, obwohl er standardmäßig in Astro integriert ist. + +Wenn dein Adapter die in Astro eingebaute Sharp-Bildoptimierung nicht unterstützt, kannst du einen [no-op image service](/de/guides/images/#configure-no-op-passthrough-service) konfigurieren, um die Komponenten `` und `` zu verwenden. + +Alternativ kannst du auch [einen von der Community gepflegten Squoosh-Bilderdienst] (https://github.com/Princesseuh/astro-image-service-squoosh) nutzen, wenn du den Sharp-Bilderdienst nicht verwenden kannst. + +##### Für Adapter + +Wenn dein Adapter zuvor seinen Kompatibilitätsstatus mit Squoosh präzisiert hat, solltest du diese Information jetzt aus deiner Adapterkonfiguration entfernen. + +```js title="my-adapter.mjs" del={2-4} +supportedAstroFeatures: { + assets: { + isSquooshCompatible: true + } +} +``` + +Lies mehr über [Konfiguration des Standard-Bilddienstes](/de/guides/images/#default-image-service). + +### Entfernt: einige öffentlich sichtbare Typen + + + +In Astro v4.x wurden mit `@types/astro.ts` alle Typen öffentlich zugänglich gemacht, unabhängig davon, ob sie noch aktiv genutzt wurden oder nur für den internen Gebrauch bestimmt waren. + +Astro v5.0 überarbeitet diese Datei, um veraltete und interne Typen zu entfernen. Diese Überarbeitung bringt Verbesserungen für deinen Editor (z. B. schnellere Vervollständigungen, geringere Speichernutzung und mehr relevante Vervollständigungsoptionen). Allerdings kann diese Überarbeitung bei einigen Projekten zu Fehlern führen, die sich auf Typen verlassen haben, die nicht mehr öffentlich verfügbar sind. + +#### Was soll ich machen? + +Entferne alle Typen, die jetzt Fehler in deinem Projekt verursachen, da du keinen Zugriff mehr auf sie hast. Dabei handelt es sich meist um APIs, die bereits veraltet sind und entfernt wurden, aber auch um Typen, die jetzt intern sind. + +Siehe die [zur Verwendung freigegebenen öffentlichen Typen](https://github.com/withastro/astro/tree/main/packages/astro/src/types/public). + +### Experimentelle Optionen + +Die folgenden experimentellen Flags wurden in Astro v5.0 entfernt, und diese Funktionen können nun verwendet werden: + +- `env` +- `serverIslands` + +Außerdem wurden die folgenden experimentellen Flags entfernt und **sind jetzt das Standard- oder empfohlene Verhalten in Astro v5.0**. + +- `directRenderScript` (Siehe unten für Änderungen am [Standard-`