GrapesJS TypeScript — Integrationsleitfaden

Vollständige Typsicherheit für deinen GrapesJS-Editor, Plugins und Komponenten

TypeScript-Arbeitsablauf

Einen sichereren GrapesJS-Editor mit vollständig getypten APIs ausliefern

Dieser Leitfaden konzentriert sich auf die praktische Implementierung: strenge Typisierung für den Lebenszyklus des Editors, Plugin-Verträge und benutzerdefinierte Komponentendefinitionen, die Ihr Team langfristig aufrechterhalten kann.

Typquelle

Eingebaute Version 1.x

Empfohlener Modus

STRICT: Wahr

Anwendungsfall

Produktionsredakteure

Wichtige GrapesJS-Typen, die du täglich verwenden wirst

Editor

Die Haupt-Editor-Instanz. Nutze es für Lebenszyklus-Events, Manager und Befehlsausführung.

Component

Repräsentiert einen Knoten im Leinwandbaum. Nützlich für typisierte Ereignishandler und benutzerdefinierte Traits.

Block

Ein schleppbarer Baustein. Typsichere Blockdefinitionen reduzieren Fehler bei Laufzeit-Inhalten.

ComponentDefinition

Verwendet beim Registrieren neuer Komponententypen über ComponentManager.addType().

ComponentProperties

Er tippt stark Standardwerte und Traits ein, damit Teammitglieder denselben Komponentenvertrag wiederverwenden.

StorageManager

Deckt Speicherkonfiguration und -abläufe für lokale oder entfernte Persistenz-Workflows ab.

Schritt 01

Beginne mit striktem TypeScript

Aktiviere den Strict-Mode und noImplicitAny, bevor du die Editor-Logik schreibst, um Fehler von Plugins und Komponenten frühzeitig zu erkennen.

Schritt 02

Gib deinen Editor-Lebenszyklus ein

Editor verwenden | null für den Initialisierungsfluss und Hinzufügen von Guards vor dem Aufruf von Manager-APIs aus asynchronen Rückrufen.

Schritt 03

Erstellen Sie typisierte Plugin-Verträge

Definiere Options-Schnittstellen mit den Standardeinstellungen, damit Plugin-APIs über Projekte und Versionen hinweg stabil bleiben.

Schritt 04

Schiffs-wiederverwendbare typisierte Komponenten

Standardisieren Sie Komponentenmerkmale und Standardwerte mit gemeinsamen TypeScript-Typen, um Teams auszugleichen.

Tippen der Editor-Instanz und Ereignisse

Lassen Sie die Editor-Initialisierung und den Ereignisfluss von Anfang an eingeschrieben. Dadurch werden ungültige Manageraufrufe und Event-Payload-Fehler frühzeitig erkannt.

  • 1. Editor verwenden | Null während der Initialisierung.
  • 2. Typisieren Sie Event-Payloads wie Component.
  • 3. Typmanager-Sammlungen beim Lesen von Blöcken/Komponenten.
editor-types.ts
import grapesjs from 'grapesjs';
import type { Editor, Component, Block } from 'grapesjs';

// Typed editor instance
let editor: Editor | null = null;

editor = grapesjs.init({
  container: '#gjs',
  storageManager: false,
});

// Typed event handlers
editor.on('component:add', (component: Component) => {
  console.log('Added component:', component.get('type'));
});

// Typed block access
const blockManager = editor.BlockManager;
const blocks: Block[] = blockManager.getAll().models;

Schreiben eines getippten GrapesJS-Plugins

Definiere Plugin-Optionen, Schnittstellen und Standardeinstellungen, um deine Erweiterung für Teams sicher und vorhersehbar über Releases hinweg vorhersehbar zu machen.

  • 1. Erstellen Sie explizite Optionsoberflächen.
  • 2. Verwenden Sie Standardwerte, um undefinierte Verzweigungen zu vermeiden.
  • 3. Plug-in-APIs abwärtskompatibel halten.
plugin.ts
import type { Editor } from 'grapesjs';

interface MyPluginOptions {
  apiKey?: string;
  debug?: boolean;
}

const myPlugin = (editor: Editor, opts: MyPluginOptions = {}) => {
  const { apiKey = '', debug = false } = opts;

  editor.BlockManager.add('custom-block', {
    label: 'Custom Block',
    category: 'Custom',
    content: '<div class="custom-block">Custom content</div>',
  });

  if (debug) {
    console.log('Plugin initialized with API key:', apiKey);
  }
};

export default myPlugin;

Typisierte benutzerdefinierte Komponentendefinition

Typisierte Komponentendefinitionen reduzieren Laufzeit-Trait-Fehler und helfen Produktteams, wiederverwendbare Inhaltsmodelle zu erstellen.

  • 1. Der Typ wird mit ComponentProperties standardisiert.
  • 2. Halte die Eigenschaften stabil und dokumentiert.
  • 3. Komponententypen mit klaren IDs registrieren.
components.ts
import type { ComponentDefinition, ComponentProperties } from 'grapesjs';

// Typed component definition
const heroComponent: ComponentDefinition = {
  model: {
    defaults: {
      tagName: 'section',
      draggable: true,
      droppable: false,
      attributes: { class: 'hero-section' },
      traits: [
        { type: 'text', name: 'headline', label: 'Headline' },
        { type: 'text', name: 'subheadline', label: 'Subheadline' },
      ],
    } as ComponentProperties,
  },
};

editor.ComponentManager.addType('hero', heroComponent);

TypeScript-Qualitätscheckliste vor dem Start

Keine Verwendung von @types/grapesjs in v1.x-Projekten
Editor-Instanz vor jedem Manager-Anruf eingegrenzt
Plugin-Optionen validiert und standardisiert
Bestandteilsmerkmale, die getypt und dokumentiert wurden
Build-Passagen mit aktiviertem Strict-Mode
Speichernutzlastform versioniert

GrapesJS TypeScript FAQ

Weiter lernen

TypeScript-kompatible Plugins auf GJS.Market

Alle Premium-Plugins enthalten TypeScript-Definitionen für eine sicherere und schnellere Integration.

Plugins durchsuchen