---
title: Migration von Stripo
description: Stripo-E-Mail-Templates mit @templatical/import-stripo in das Templatical-Format konvertieren.
---

# Migration von Stripo

Diese Anleitung richtet sich an Teams, die E-Mail-Templates in [Stripo](https://stripo.email) erstellt haben — im gehosteten Editor oder über ein Produkt, das das Stripo-Plugin einbettet — und auf Templaticals visuellen Editor wechseln möchten. **`@templatical/import-stripo`** konvertiert Stripo-HTML in Templaticals `TemplateContent`-Format. Installieren Sie es, führen Sie es aus, und nutzen Sie die folgenden Abschnitte, um alles nachzuarbeiten, was es nicht automatisch abbilden kann.

Stripo speichert zwei verschiedene HTML-Oberflächen. Der Konverter erkennt selbst, welche Sie übergeben. Es gibt kein Mode-Flag.

| Oberfläche | Herkunft | Unterscheidungsmerkmal |
|---|---|---|
| Plugin- / Editor-Speicher | `getTemplateData()` → `{ html, css }` | `esd-stripe`, `esd-structure`, `esd-block-*` auf Elementen |
| Kompilierter Export | Datei → HTML, oder `compileEmail({ callback })` | `es-wrapper`, `es-content-body`, `es-header-body` — kein `esd-*` auf Elementen |

Eine übrig gebliebene Regel `.esd-block-html` in einem Stylesheet ist kein Unterscheidungsmerkmal. Rein CSS-seitige Reste werden als generisches HTML konvertiert.

## Installation

::: code-group

```bash [npm]
npm install @templatical/import-stripo
```

```bash [pnpm]
pnpm add @templatical/import-stripo
```

```bash [yarn]
yarn add @templatical/import-stripo
```

```bash [bun]
bun add @templatical/import-stripo
```

:::

### Ohne Build-Schritt (CDN)

```html
<script type="module">
  import { convertStripoTemplate } from 'https://cdn.jsdelivr.net/npm/@templatical/import-stripo/+esm';
  // ...dann wie unter Verwendung konvertieren
</script>
```

## Verwendung {#usage}

```ts
import { convertStripoTemplate } from '@templatical/import-stripo';

// Plugin-Host — was Sie aus getTemplateData() gespeichert haben:
const { html, css } = await window.StripoApi.getTemplateData();
const { content, report } = convertStripoTemplate(html, { css });

// Marketer-Export Datei → HTML:
const exported = await fetch('/path/to/export.html').then((r) => r.text());
const compiled = convertStripoTemplate(exported);

const editor = await init({
  container: '#editor',
  content: compiled.content,
});
```

[Im Playground öffnen](https://play.templatical.com/scenes/import-stripo)

`convertStripoTemplate` ist synchron und gibt ein `ImportResult` zurück mit:

- `content` — das konvertierte `TemplateContent`, bereit für den Editor
- `report` — ein Konvertierungsbericht mit dem Status jedes Quellelements (`converted`, `approximated`, `html-fallback` oder `skipped`)

Übergeben Sie `options.css` zusammen mit dem Plugin-Speicher (`getTemplateData().css`). Diese Regeln gelten für jede Zelle, die der HTML-Importer konvertiert. Ein kompilierter Datei → HTML-Export trägt dieselben Regeln bereits inline.

Nicht erkanntes HTML (keine Stripo-Klassenattribute) läuft durch `@templatical/import-html`; der Bericht enthält eine Warnung, die diesen Fallback benennt.

## Optionen {#options}

`convertStripoTemplate` akzeptiert als zweites Argument `ConvertStripoOptions`. `defaultLocale?: string` setzt `settings.locale`, wenn die Quelle keine Standardsprache angibt; andernfalls gilt `"en"`. Eine deklarierte Standardsprache hat Vorrang. Sprachcodes werden von `_` nach `-` normalisiert. Eine deklarierte Standardsprache oder ein `defaultLocale`, das danach kein Sprach-Tag ist, etwa ein Platzhalter <code v-pre>{{lang}}</code>, wird mit einem `report.warnings`-Eintrag ignoriert, der den Wert nennt; dann gilt der nächste gültige Wert oder `"en"`.

`ConvertStripoOptions` behält außerdem `css?: string` für den Plugin-Speicher. HTML `<html lang>` deklariert die Standardsprache.

```ts
export interface ConvertStripoOptions {
  defaultLocale?: string;
  css?: string;
}
```

## Den Bericht lesen

Jeder Eintrag in `report.entries` beschreibt ein Quellelement:

| Status | Bedeutung |
|---|---|
| `converted` | Auf einen Templatical-Block abgebildet, ohne Verlust. |
| `approximated` | Auf einen Templatical-Block abgebildet, mit einer Begrenzung oder einem Flatten — `note` nennt die Änderung. |
| `html-fallback` | Kein Block-Äquivalent; das Original-Markup liegt in einem `HtmlBlock`. |
| `skipped` | Für die Parität mit den anderen `@templatical/import-*`-Paketen reserviert; dieser Konverter erzeugt das derzeit nicht. |

Der Bericht listet die Blöcke, die in `content` bleiben, einschließlich jedes Abschnitts, den Stripo erzeugt. Ein `<tr>`-Abschnitt, den der HTML-Importer beim Durchlaufen einer Zelle anlegt, entfällt. Warnungen aus diesem Durchlauf bleiben.

```ts
console.log(report.summary);
// { total: 18, converted: 16, approximated: 1, htmlFallback: 1, skipped: 0 }

for (const entry of report.entries) {
  if (entry.status === 'approximated') {
    console.warn(`<${entry.sourceTag}> approximated:`, entry.note);
  }
}
```

## Weg 1 — Visuell neu aufbauen, mit dem Stripo-Export als Referenz

Bei wenigen Templates ist der Neuaufbau per Hand neben einer kompilierten Vorschau oft schneller als ein Paket zu installieren:

1. Exportieren Sie Datei → HTML aus Stripo und öffnen Sie es im Browser — das ist Ihr visuelles Ziel.
2. Öffnen Sie den Templatical-Editor (oder [den Playground](https://play.templatical.com)) daneben.
3. Ziehen Sie die entsprechenden Templatical-Blöcke herein (siehe die Mapping-Tabellen unten).
4. Kopieren Sie den Text direkt. Hosting Sie Bilder über Ihre Medienbibliothek neu.

Die meisten Stripo-Templates sind in 10–20 Minuten umgezogen, sobald Sie eines oder zwei gemacht haben. Bei größeren Mengen führen Sie zuerst `@templatical/import-stripo` aus und nutzen diesen Weg nur, um nachzuarbeiten, was als `approximated` oder als `html-fallback`-Block gelandet ist.

## Mapping des Plugin-HTML {#plugin-mapping}

Plugin-Speicher ist ein Tabellenbaum mit `esd-*`-Klassen. Jedes `esd-structure` wird ein `SectionBlock`; seine `esd-container-frame`-Kinder sind die Spalten.

| Stripo-Marker | Templatical-Block | Hinweise |
|---|---|---|
| `esd-structure` mit 1–4 `esd-container-frame`s | `SectionBlock` (`columns` aus Anzahl und Breiten der Frames; siehe Spaltengeometrie unter [Wo das Mapping verlustbehaftet ist](#lossy)) | Frames sind die Spalten. Das Padding kommt von `es-p*` an der Structure (Standard 0); ein Inline-`padding` überschreibt die Seiten, die es nennt. |
| `esd-structure` mit 5+ Frames | `SectionBlock` `columns: "1"` | Auf eine Spalte reduziert; `approximated`. |
| `esd-block-text` | `title` / `paragraph` | Generisches HTML-Mapping des inneren Markups. |
| `esd-block-image` | `image` | Generisches HTML-Mapping des inneren `<img>`, einschließlich seiner [Breitenregel](/de/guide/migration-from-html#image-width). |
| `esd-block-button` | `button` | `href`, Text, `target="_blank"` → `openInNewTab`. Inline `background` / `color` / `border-radius`, sofern vorhanden. Inline-`font-size` (vom Anker, sonst vom umschließenden `es-button-border`) wird zu `fontSize`, wenn sie eine px-Länge oder eine bloße Zahl ist, auf ganze Pixel gerundet; jeder andere Wert oder einer, der auf 0 oder darunter gerundet wird, wird mit der Factory-Größe von 15px importiert, `approximated`. Inline-`line-height` (vom Anker, sonst vom umschließenden `es-button-border`, wobei ein Prozent- oder `em`-Wert zuerst an dessen `font-size` aufgelöst wird und ein `inherit` am Anker den Wert des Wrappers übernimmt; setzt der Anker eine eigene `font-size` und fehlt die des Wrappers oder ist sie kein px, gilt für den Wrapper ersatzweise 15px, und der Button wird vermerkt) wird zu `lineHeight`, einem Vielfachen der Schriftgröße: `150%` ist `1.5`, eine Zahl oder `em`-Länge ist sie selbst, und eine px-Länge wird durch die Schriftgröße des Buttons geteilt; `font-size:18px; line-height:27px` ergibt also `1.5`. Ein Prozent- oder `em`-Wert neben einer nicht lesbaren `font-size` des Ankers behält sein Verhältnis zu dieser 15px-Beschriftung. Ein `120%` am Anker, `normal` und ein fehlender Wert bleiben ungesetzt (1.2); ein `120%` am Wrapper wird wie jeder andere Prozentwert des Wrappers aufgelöst und bleibt nur ungesetzt, wenn es 1.2 der Beschriftung ergibt. Ein nicht lesbarer Wert wird mit 1.2 importiert, `approximated`. |
| `esd-block-menu` (2+ Item-Zellen) | `menu` | Ein `MenuItemData` je Item-Zelle. |
| `esd-block-menu` (1 Item-Zelle) | `paragraph` (oder das innere Mapping) | Ein gestapelter Schritt, keine Navigation — Password-Reset-Zeilen bleiben Fließtext. |
| `esd-block-social` | `social` | Plattform aus `title` / `src` / `alt`. Ein unbekanntes Icon mit Bild wird ein benutzerdefiniertes Icon (eigenes Bild, Link und Alt-Text) im selben Social-Block. Ohne Bild wird es ein Website-Icon, und der Block wird als `approximated` gemeldet. |
| `esd-block-spacer` | `spacer` oder `divider` | Ein sichtbarer `border-bottom` oder `border-top` am Spacer oder in der inneren Zelle wird ein Trenner (Stil, Farbe, Stärke und die Breitenregel unten). Sonst ein Spacer: Höhe aus `style`, dem `height`-Attribut oder dem vertikalen Padding. |
| `esd-block-html` | `html` | Inneres Markup bleibt erhalten. |

## Mapping des kompilierten HTML {#compiled-mapping}

Der kompilierte Export entfernt `esd-*` von den Elementen und behält `es-*`-Reste. Jede direkte Zeile eines Streifens wird ein eigener Abschnitt, in Dokumentreihenfolge. Spalten sind die gefloateten Tabellen `es-left` / `es-right` in dieser Zeile.

| Stripo-Marker | Templatical-Block | Hinweise |
|---|---|---|
| `es-header` / `es-content` / `es-footer` | ein oder mehrere `SectionBlock`s | Ein Abschnitt je direkter Zeile des `es-*-body` im Streifen. Ein Streifen ohne `es-*-body` verwendet seine eigenen Zeilen. Eine leere Zeile entfällt. |
| Inhalt neben den Spalten in derselben Zelle | einspaltiger `SectionBlock` | Führender Inhalt bleibt vor dem Spaltenabschnitt, nachfolgender Inhalt danach. Inhalt, der zwischen den Spalten stand, wird hinter den Spaltenabschnitt gesetzt (`approximated`). Eine Zelle mit Padding, die in mehr als einen Abschnitt zerfällt, ist `approximated`: das obere Padding bleibt am ersten Abschnitt, das untere am letzten, die Seiten an jedem. |
| 1–4 `es-left` / `es-right` in einer Zeile | `columns` aus Anzahl und Breiten der Spalten; siehe Spaltengeometrie unter [Wo das Mapping verlustbehaftet ist](#lossy) | Gefloatete Tabellen in dieser Zeile, auch Tabellen in einem Wrapper. Spalten innerhalb eines weiteren `es-left` / `es-right` bleiben darin. |
| 5+ gefloatete Tabellen in einer Zeile | `columns: "4"` | Weitere Spalten landen im vierten Slot; `approximated`. |
| `a.es-button` | `button` | Inline `background` / `color` / `border-radius` / `font-size` / `line-height`, einschließlich vom umschließenden `es-button-border`, gelesen wie bei `esd-block-button`. Widgets bleiben in Dokumentreihenfolge beim Text um sie herum. |
| `table.es-menu` (2+ Item-Zellen) | `menu` | |
| `table.es-menu` (1 Item-Zelle) | inneres Mapping | Eine Schrittzeile, dieselbe Regel wie beim Plugin-Pfad. |
| `table.es-social` | `social` | Dasselbe Plattform-Mapping wie beim Plugin-Pfad. Ein unbekanntes Icon mit Bild wird ein benutzerdefiniertes Icon (eigenes Bild, Link und Alt-Text) im selben Social-Block. Ohne Bild wird es ein Website-Icon, und der Block wird als `approximated` gemeldet. |
| `es-spacer` mit sichtbarem Rahmen | `divider` | Stil, Farbe und Stärke aus `border-bottom` oder `border-top`. Die Breite folgt der Regel unten. |
| `es-spacer` ohne Rahmen | `spacer` | Höhe aus `style`, dem `height`-Attribut oder dem vertikalen Padding. |

`settings.backgroundColor` ist die erste gesetzte Farbe von `es-wrapper` oder `es-wrapper-color` (`#ffffff`, wenn keine gesetzt ist). Eine `es-*-body`-Füllung ist der Hintergrund des Abschnitts. Ein Streifen (`esd-stripe` oder `es-header` / `es-content` / `es-footer`) um diesen Body, dessen Farbe von der Seite abweicht, ist ein fensterbreites Band: die Farbe wird `section.wrapper.backgroundColor` mit `wrapper.fullWidth: true`, sodass das Band bis zum Fensterrand läuft und der Inhalt auf der E-Mail-Breite bleibt, auch wenn die Streifenfarbe der Body-Farbe entspricht. Ein transparenter Body verschiebt diese Farbe vom Abschnitt auf den Wrapper. Eine Streifenfarbe, die der Seite entspricht, bleibt vom Wrapper. Ein Streifen ohne inneren Body behält seine Farbe auf dem Abschnitt. Hintergrundbilder, und was sie mit dieser Streifenfarbe tun, folgen [Hintergrundbilder](#hintergrundbilder).

Das Padding der Strukturzelle ist das Padding des Abschnitts. Der Standard ist 0. Im Plugin-HTML setzt `es-p20` jede Seite und `es-p10t` / `es-p10r` / `es-p10b` / `es-p10l` überschreibt eine Seite; ein Inline-Padding überschreibt die Seiten, die es nennt. Diese Klassen werden am Structure-Element gelesen.

Die Breite eines Trenners gilt für die Spalte, in der er steht. Fehlende Breite, `auto` oder `100%` füllt diese Spalte. Ein anderer Prozentwert bleibt ein Prozentwert, auf zwei Dezimalstellen gerundet und auf 0–100 begrenzt. Eine px-Breite bleibt px, bis sie den Raum der Spalte füllt (der Anteil der Spalte, gemäß ihrem Layout oder ihren `columnWidths`, an der inneren Box des Abschnitts, also an der Body-Breite abzüglich des linken und rechten Abschnitts-Paddings, dann abzüglich des eigenen Seiten-Paddings des Trenners). `double`, `groove`, `ridge`, `inset` und `outset` werden als `solid` importiert. Eine schmalere Linie mit Ausrichtung links oder rechts wird zentriert; dieser Eintrag ist `approximated`. Eine schmalere Linie ohne Ausrichtung gilt als links.

Alles andere in einer Zeile läuft durch `@templatical/import-html` (Überschriften, Absätze, Bilder, `<hr>`-Trenner).

### Hintergrundbilder

Das Bild eines Elements wird aus seinem Inline-`background-image`, dem Bild in seiner `background`-Kurzschreibweise oder seinem `background`-Attribut gelesen. Ein Abschnitt übernimmt das nächstgelegene:

1. Das eigene Bild der Structure: die Zeilenzelle, `esd-structure` im Plugin-HTML.
2. Das Bild des `es-*-body`, der Inhaltsfläche hinter jeder Structure im Streifen.
3. Die Bilder der Container (`es-left` / `es-right` oder `esd-container-frame`), wenn es nur einen Container gibt oder alle dasselbe Bild teilen. Andernfalls, oder neben einem näheren Bild, werden sie verworfen, und die Notiz nennt die Spalten.
4. Das Bild des Streifens wird `wrapper.backgroundImage` mit `wrapper.fullWidth: true`, auch wenn der Body es verdeckt. Ein Streifen ohne inneren Body behält seine Farbe auf dem Abschnitt und legt dieses Bild trotzdem auf den Wrapper.

Ein Bild hinter mehreren Abschnitten, etwa ein Body-Bild oder ein Streifenbild über mehrere Structures, wird auf jeden kopiert, und jeder dieser Einträge ist `approximated` mit einer Notiz. Hat ein Abschnitt ein Bild, wird eine Streifenfarbe, die `section.wrapper.backgroundColor` geworden wäre, stattdessen mit einer Notiz verworfen, denn Outlook für Desktop malt eine Wrapper-Farbe über das Bild des Abschnitts. Das Streifenbild bleibt auf dem Wrapper. Ein Bild am `es-wrapper` hat keine Templatical-Entsprechung, und `report.warnings` nennt es.

`background-size`, `background-position` und `background-repeat` werden mitgenommen, wo nicht gesetzt mit den CSS-Anfangswerten. Eine Größe, die eine Seite füllt (`100%`, `100% auto` oder eine px-Breite mindestens so groß wie der Body), wird `cover`, jede andere Länge oder Prozentangabe `auto`. Eine Prozent-Position rastet auf das nächste von links, Mitte und rechts (oben, Mitte und unten) ein, eine Länge auf den linken bzw. oberen Rand. `repeat-x`, `repeat-y`, `round` und `space` werden zu `repeat`. Jeder solche Wert wird vermerkt.

## Wo das Mapping verlustbehaftet ist {#lossy}

- **Spaltengeometrie** — Templatical unterstützt diese Spaltenlayouts (`1`, `2`, `3`, `4`, `2-1`, `1-2`, `3-1`, `1-3`, `1-2-1`). Eine Zeile mit zwei bis vier Spalten liest die px-Breite jeder Spalte aus ihrem Plugin-Frame oder ihrer kompilierten Tabelle `es-left` / `es-right`. Der Anteil einer Spalte ist ihre Breite geteilt durch die Summe der Breiten der Zeile; der Abstand zwischen den Spalten ist also kein Anteil. Breiten innerhalb von 1px zueinander ergeben das gleichmäßige Layout `2`, `3` oder `4`. Breiten innerhalb von 1px zu `2-1`, `1-2`, `3-1`, `1-3` oder `1-2-1` ergeben dieses Layout: `200px` / `400px` ist `1-2`. Alle anderen Breiten behalten das gleichmäßige Layout und setzen [`columnWidths`](/de/guide/sections-and-columns#custom-column-widths) auf ihre auf 100 skalierten Anteile: `180px` / `420px` ist `2` mit `[30, 70]`. Alle diese Fälle bleiben `converted`. Hat eine Spalte keine lesbare Breite, hat die Zeile kein Verhältnis und behält das gleichmäßige Layout. Der Abschnitt ist `approximated`, mit einer Notiz, die jede Breite nennt, wenn mindestens zwei lesbare Breiten um mehr als 1px voneinander abweichen; bei weniger als zwei lesbaren Breiten oder lesbaren Breiten innerhalb von 1px bleibt er `converted`. Plugin-HTML mit 5 oder mehr Frames wird auf eine Spalte reduziert. Kompiliertes HTML mit 5 oder mehr gefloateten Tabellen in einer Zeile behält vier Slots und faltet den Rest in den letzten. Inhalt zwischen diesen Spalten wird ein eigener einspaltiger Abschnitt dahinter, und eine Zelle mit Padding, die über die entstehenden Abschnitte aufgeteilt wird, ist `approximated`.
- **Social-Icon-`alt`** — ein unerkanntes Icon mit Bild wird ein eigenes Icon und behält seinen `alt`-Text (oder `title`); eine erkannte Plattform wird mit dem eingebauten Icon von Templatical gezeichnet und speichert keinen `alt`-Text.
- **Block-IDs** — jeder importierte Block bekommt eine neu erzeugte ID.
- **AMP / Timer / Module** — kein Templatical-Äquivalent; inneres Markup landet als `html` oder wird mit Warnung übersprungen.
- **Plugin-CSS** — übergeben Sie `options.css` mit dem Plugin-Speicher. Regeln, die nur in diesem Stylesheet stehen, werden auf die konvertierten Blöcke angewendet. Kompilierte Exporte tragen sie bereits inline.

## Was nicht automatisch abgebildet wird

- **Ein Roundtrip zurück nach Stripo** — die Ausgabe ist Templatical-JSON, kein Stripo-Editor-HTML.
- **Generisches HTML, das nie ein Stripo-Dokument war** — verwenden Sie [`@templatical/import-html`](/de/guide/migration-from-html) direkt. Hier übergeben konvertiert es trotzdem, mit einer Warnung.

## Weitere Hilfe

[Eröffnen Sie eine Diskussion](https://github.com/templatical/sdk/discussions) mit einem geschwärzten Ausschnitt Ihres Stripo-HTML und dem, was Sie erreichen wollen. Wir nutzen diese Rückmeldungen, um die Abdeckung von `@templatical/import-stripo` zu verbessern.
