GrapesJS TypeScript — Guía de integración

Seguridad total de tipos para tu editor, plugins y componentes GrapesJS

Flujo de trabajo TypeScript

Lanza un editor GrapesJS más seguro con APIs completamente tecleandas

Esta guía se centra en la implementación práctica: tipificación estricta para el ciclo de vida del editor, contratos de plugins y definiciones personalizadas de componentes que tu equipo pueda mantener a largo plazo.

Fuente tipográfica

Versión 1.x integrada

Modo recomendado

Estricto: Cierto

Caso de uso

Editores de producción

Tipos clave de GrapesJS que usarás a diario

Editor

La instancia del editor principal. Úsalo para eventos del ciclo de vida, gestores y ejecución de comandos.

Component

Representa un nodo en el árbol de lienzo. Útil para manejadores de eventos tipados y rasgos personalizados.

Block

Un bloque de construcción arrastrable. Las definiciones de bloques seguras para tipos reducen errores en el contenido en tiempo de ejecución.

ComponentDefinition

Se utiliza al registrar nuevos tipos de componentes a través de ComponentManager.addType().

ComponentProperties

Tipifica fuertemente los valores predeterminados y rasgos para que los miembros del equipo reutilicen el mismo contrato de componente.

StorageManager

Cubre la configuración y operaciones de almacenamiento para flujos de trabajo de persistencia locales o remotas.

Escalón 01

Empieza con un TypeScript estricto

Activa el modo estricto y noImplicitAny antes de escribir la lógica del editor para detectar errores de plugins y componentes a tiempo.

Escalón 02

Escribe el ciclo de vida de tu editor

Usar Editor | null para el flujo de inicialización y añadir guards antes de llamar a las APIs del gestor desde callbacks asincrónicos.

Escalón 03

Crear contratos de plugins tipados

Define interfaces de opciones con los valores predeterminados para que las APIs de plugins se mantengan estables entre proyectos y versiones.

Escalón 04

Componentes tipo reutilizables para barcos

Estandariza los rasgos y valores predeterminados de los componentes con tipos compartidos de TypeScript para mantener a los equipos alineados.

Tipificación de la instancia del editor y eventos

Mantén la inicialización del editor y el flujo de eventos tipados desde el primer día. Esto detecta las llamadas de administrador inválidas y los errores de carga útil de eventos a tiempo.

  • 1. Usar editor | null durante la inicialización.
  • 2. Tipifica cargas útiles de eventos como Componente.
  • 3. Colecciones del gestor de tipos al leer bloques/componentes.
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;

Escribiendo un plugin GrapesJS tipado

Define interfaces de opciones de plugin y valores predeterminados para que tu extensión sea segura para los equipos y predecible en todas las versiones.

  • 1. Crear interfaces de opciones explícitas.
  • 2. Utilizar valores predeterminados para evitar ramas indefinidas.
  • 3. Mantén las APIs de plugins compatibles hacia atrás.
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;

Definición de componente personalizado tipado

Las definiciones de componentes tipados reducen errores de rasgos en tiempo de ejecución y ayudan a los equipos de producto a crear modelos de contenido reutilizables.

  • 1. Tipos predeterminados con ComponentProperties.
  • 2. Mantener estables y documentados los nombres de rasgos.
  • 3. Tipos de componentes de registro con identificadores claros.
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);

Lista de verificación de calidad de TypeScript previa al lanzamiento

No se usa @types/grapesjs en proyectos v1.x
Instancia del editor reducida antes de cada llamada de gerente
Opciones de plugin validadas y predeterminadas
Rasgos de los componentes tipificados y documentados
Compilación pasa con modo estricto activado
Forma de carga útil de almacenamiento versionada

Preguntas frecuentes sobre GrapesJS TypeScript

Sigue aprendiendo

Plugins compatibles con TypeScript en GJS. Mercado

Todos los plugins premium incluyen definiciones TypeScript para una integración más segura y rápida.

Explorar plugins