ModaEditor — Editor

Core headless — React/Vue/Svelte/vanilla.

Editor de texto enriquecido headless e independiente del framework, con documentos JSON AST inmutables y transacciones.

Toda la lógica — modelo de documento, transacciones, selección, binding de entrada — vive en un núcleo TypeScript puro; cada adaptador solo es un binding reactivo. Cinco renderizadores emiten el mismo contrato DOM, así que se comporta igual en todas partes.

Un solo bundle inicial incluye marcas, encabezados, citas, listas, tareas, tablas, bloques de código, enlaces, imágenes, alineación e historial — ampliable sin límite vía Extension/Plugin/InputRule.

Gratis (MIT)React · Vue 3 · Vue 2.7 · Svelte 5 · VanillaEditorState inmutable · transaccionesTypeScript

Demo en vivo

Funciona con el núcleo real cargado por CDN. Cada botón de la barra corresponde 1:1 a una llamada editor.commands.* (el tooltip muestra la API); cada edición muestra la serialización HTML y el JSON del documento en el panel inferior, y abajo fluyen los eventos suscritos con editor.on().

Paquetes por entorno

EntornoPaqueteNotas
React@moda-editor/reactuseEditor + EditorView; vistas de nodo son componentes React
Vue 3@moda-editor/vueuseEditor + EditorView SFC, useEditorState suscribe fuera
Vue 2.7@moda-editor/vue2Mismo uso de Composition API que Vue 3
Svelte 5@moda-editor/sveltecreateEditorStore + EditorView, binding readable store
JS puro / CDNmoda-editor.jsUn <script>, sin build — window.ModaEditor
Sin framework@moda-editor/coreUsa createEditor + mountEditor headless directo

Instalar con npm

npm i @moda-editor/react # React
npm i @moda-editor/vue # Vue 3
npm i @moda-editor/vue2 # Vue 2.7
npm i @moda-editor/svelte # Svelte 5
npm i @moda-editor/core # Solo núcleo headless
npmjs.com/package/@moda-editor/react →

Usar con CDN

https://editor.modaolive.com/moda-editor.js
https://editor.modaolive.com/style.css

Empieza en 3 pasos

  1. 1

    Instalar paquete

    Instala un adaptador como npm i @moda-editor/react, o carga el núcleo con un <script> de CDN.

  2. 2

    Pas extensiones

    starterExtensions() incluye esquema·comandos·teclas·reglas de entrada·historial. Pasa el JSON inicial con doc.

  3. 3

    Render y control

    Los adaptadores solo necesitan un <EditorView>. Conecta la barra a editor.commands.*; vanilla usa mountEditor(el, options).

// npm i @moda-editor/react
import { EditorView, starterExtensions, useEditor } from "@moda-editor/react";
import "@moda-editor/react/styles.css";

function App() {
  const { editor, state } = useEditor({
    doc: myDoc,                       // DocNode JSON (doc vacío si se omite)
    extensions: starterExtensions(),  // esquema·comandos·teclas·historial del starter
  });

  return (
    <>
      <button onClick={() => editor.commands.toggleBold()}>B</button>
      <button onClick={() => editor.commands.setHeading(2)}>H2</button>
      <EditorView editor={editor} />
    </>
  );
}
// state es un EditorState inmutable — === decide si hay que re-renderizar

EditorState es inmutable — devuelve la misma referencia hasta que cambia, garantizando estructuralmente el contrato de snapshot de React useSyncExternalStore.

Uso por función — qué usar

Toda función corre con comandos/opciones del núcleo — los adaptadores solo los reenvían. Pasa el cursor por los botones de la demo para ver la API.

Formato (marcas inline)

FunciónCómo activar (opción/prop/entrada)API núcleo
Negrita·cursiva·subrayadoToolbar / Mod-B·I·Ucommands.toggleBold() / toggleItalic() / toggleUnderline()
TachadoBotóncommands.toggleStrike()
Super/subíndice—commands.toggleSuperscript() / toggleSubscript()
Código inlineBotóncommands.toggleCode()
Cambiar atributos de marca—commands.setMarkAttr("link", { href })
Limpiar formato—clearFormat (helper del starter)

Bloques

FunciónCómo activar (opción/prop/entrada)API núcleo
TítulosBotóncommands.setHeading(1~6)
CitaBotóncommands.toggleQuote()
Bloque de códigotoggleCodeBlock — incluye selector de lenguajecommands.setCodeLanguage(lang) / highlightCode
Línea · salto forzado—commands.insertHorizontalRule() / insertHardBreak()
AlineaciónAl registrar la feature de alineacióncommands.setAlign("left"|"center"|"right")
Dividir / salir del bloqueEnter / Mod-Entercomandos splitBlock / exitBlock

Listas y tablas

FunciónCómo activar (opción/prop/entrada)API núcleo
Listas con viñetas · numeradasBotóncommands.toggleBulletList() / toggleOrderedList()
Lista de tareasBotóncommands.toggleTaskList() / toggleTaskItem()
Sangría / quitar sangríaTab / Shift-Tabcommands.sinkListItem() / liftListItem()
Insertar tabla · filas · columnas—commands.insertTable(r,c) / addTableRow / addTableColumn / deleteTable
Moverse por celdasTab dentro de una tablanextCell / prevCell

Enlaces, imágenes y pegado

FunciónCómo activar (opción/prop/entrada)API núcleo
EnlaceBarra / regla de entrada [texto](url)commands.setLink(href) / unsetLink()
ImagenInsertar URL / pegar · soltarcommands.insertImage(src, alt) / updateImage / deleteImage
Hook de subida de imagenOpción onImageUpload — File → URL asíncronoSi se omite, inserta al instante como data URL de FileReader
Saneado de HTML pegadoAutomático — elimina script·on*·javascript:pipeline integrado parseHTML + sanitizeHTML
Pegado de Word · Google DocsAutomático — evita negritas espurias y aplanado de wrappersAl pegar externo: limpieza estructural + omite historial
evento paste—editor.on("paste", ({html, text}) => …)

Estado, eventos e historial

FunciónCómo activar (opción/prop/entrada)API núcleo
Estado inmutable—editor.state — misma referencia hasta que cambia
Suscripción de renderLos adaptadores lo conectan soloseditor.subscribe(fn) / getSnapshot()
Eventos semánticos—editor.on("update"|"selectionUpdate"|"transaction"|"focus"|"blur"|"destroy")
Deshacer / rehacerstarterExtensions incluye history, Mod-Z / Mod-Shift-Zcommands.undo() / redo(), canUndo / canRedo
Solo lecturaEditorOptions.editable: falseSeñal para desactivar contenteditable
Colaboración (CRDT)bindCollab — @moda-editor/collab-yjsBinding de ciclo de vida vía subscribe·apply, mapeo de posición basado en Point
Despacho manual—editor.dispatch(tr) — punto único para todos los cambios

Documento y extensiones

FunciónCómo activar (opción/prop/entrada)API núcleo
Modelo JSONdoc: opción DocNodecreateDoc(content) / createText(text, marks)
Serialización HTML—serializeToHTML(doc, schema)
HTML → doc—parseHTML(html, schema) → createDoc(nodes)
Vista de nodo personalizadaProp nodeViews de EditorView{ codeBlock: MyComponent } — NodeViewProps
Sistema de extensionesArray extensionsExtension = nodes + marks + commands + keymap + inputRules + plugins
Bundle inicialextensions: starterExtensions()Esquema·comandos·teclas·reglas·historial en uno
TemaVariables --me-* en styles.cssContrato de clases .me-* para custom

Recetas frecuentes

Fragmentos listos para copiar.

Conectar botones

editor.commands es el registro de comandos — conecta a onClick

<button onClick={() => editor.commands.toggleBold()}>B</button>
<button onClick={() => editor.commands.setHeading(2)}>H2</button>
<button onClick={() => editor.commands.toggleTaskList()}>{t.todoL}</button>
<button onClick={() => editor.commands.undo()}>↶</button>

// devolver false = no aplicable en la selección actual → usarlo como señal para deshabilitar el botón

Autoguardado (evento update)

Emitido en cada cambio — debounce y envía al servidor

editor.on("update", ({ state, prevState }) => {
  if (state.doc === prevState.doc) return;  // omite si solo cambió la selección
  scheduleSave(serializeToHTML(state.doc, editor.schema));
});

// o guarda el JSON del documento tal cual
const payload = JSON.stringify(state.doc);

Cargar HTML → doc

Parsea HTML existente a doc inicial — sanitizer integrado elimina etiquetas peligrosas

import { createEditor, createDoc, parseHTML, starterExtensions }
  from "@moda-editor/core";

const extensions = starterExtensions();
const boot = createEditor({ extensions });
const doc = createDoc(parseHTML(savedHtml, boot.schema));

const editor = createEditor({ extensions, doc });

Subida de imagen

Files de pegar/soltar/selector se reemplazan con URLs del servidor

useEditor({
  extensions: starterExtensions(),
  onImageUpload: async (file) => {
    const form = new FormData();
    form.append("file", file);
    const res = await fetch("/api/upload", { method: "POST", body: form });
    return (await res.json()).url;   // el editor lo inserta como src
  },
});

Vista de nodo custom (React)

Reemplaza el render de un tipo de nodo — content obtiene un outlet

function CodeBlockView({ node, editor, path, content }: NodeViewProps) {
  return (
    <div className="my-codeblock">
      <select onChange={(e) =>
        editor.commands.setCodeLanguageAt(path, e.target.value)} />
      {content}   {/* área de edición — hay que renderizarla */}
    </div>
  );
}

<EditorView editor={editor} nodeViews={{ codeBlock: CodeBlockView }} />

Log de eventos y sync

transaction emite cada tr pre-filtro — el hook más bajo para debug/sync

editor.on("transaction", ({ tr, state }) => console.log(tr.steps));
editor.on("paste", ({ html, text }) => console.log(t.pasteL, text));
editor.on("blur",  () => saveDraft());
editor.on("destroy", () => cleanup());

// compartir con la vista un editor creado fuera
const editor = createEditor({ extensions: starterExtensions() });
<EditorView editor={editor} />   // la vista gestiona la suscripción

Mismo comportamiento en todos los frameworks

Los renderizadores de React, Vue, Svelte y Vanilla emiten el mismo contrato DOM (clases .me-*) y se verifican con la spec compartida (runWidgetConformance). La API y las variables CSS (--me-*) funcionan igual en todas las plataformas.

Código y docs

github.com/park-taejoon/moda-editor-releases
  • Guías por plataforma — React / Vue 3 / Vue 2.7 / Svelte 5 / Vanilla
  • Guías de funciones — nodeViews custom, ejemplo lista con búsqueda
  • Temas — variables --me-*, doc de migración

Cómo usar

Core headless — React/Vue/Svelte/vanilla.

rich text editor

Herramientas relacionadas