Diseñar e implementar un editor SVG que se completa solo en el navegador
Los tropiezos al construir un editor SVG que funciona íntegramente en el navegador.
Diseñar e implementar un editor SVG que se completa solo en el navegador
Intenté construir el editor SVG (/es/tools/svgedit/) codo a codo con ChatGPT —en realidad dando instrucciones como gestor— y este texto resume todos los tropiezos que encontré.
¿Qué es SVG?
SVG (Scalable Vector Graphics) es un formato de imagen vectorial basado en XML estandarizado por el W3C. A diferencia de las imágenes rasterizadas (como PNG o JPEG), puede ampliarse o reducirse sin perder calidad. Además, se puede incrustar directamente en un documento HTML como parte del DOM, por lo que permite manipulación dinámica mediante JavaScript y CSS. La especificación sigue la recomendación SVG del W3C e incluye formas, texto, trazados, degradados, filtros y más recursos expresivos.
SVG se utiliza ampliamente en casos como los siguientes:
- Mostrar iconos o diagramas en páginas web.
- Generar diagramas y gráficos dinámicos.
- Crear aplicaciones de dibujo con interacción de usuario.
- Preparar recursos para impresión o diseño de interfaces.
Descripción general del editor
El editor es una herramienta completamente del lado del cliente que se ejecuta en el navegador. Permite dibujar no solo rectángulos y elipses, sino también estrellas, globos de diálogo, nubes, corazones y curvas libres con un modo pluma. Las figuras pueden moverse, escalarse y rotarse; además cuenta con alineación, ajuste (snap), agrupación y una lista de capas. El resultado final puede exportarse como SVG o PNG.
A continuación explico cómo llevé la especificación de SVG a JavaScript y en qué puntos me tropecé.
Cómo reflejar la especificación en la implementación y los tropiezos
Añadir figuras y gestionar atributos
La especificación SVG define elementos y atributos específicos por tipo de figura. Los rectángulos usan <rect>, las elipses <ellipse>, los polígonos <polygon>, y cada uno requiere atributos como x, y, width, height, cx, cy, rx, ry o points configurados correctamente. Las formas complejas —estrellas, corazones— se generan con <path> combinando curvas Bézier y comandos de arco.
Ejemplo de implementación (alta de un rectángulo)
function addRectangle(x, y, width, height) {
const rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
rect.setAttribute("x", x);
rect.setAttribute("y", y);
rect.setAttribute("width", width);
rect.setAttribute("height", height);
rect.setAttribute("fill", "transparent");
rect.setAttribute("stroke", "#000");
svg.appendChild(rect);
}
Rectángulos y elipses son sencillos, pero los polígonos o formas personalizadas exigen cálculos de coordenadas. Para dibujar una estrella, por ejemplo, hay que dividir el ángulo central, calcular cada vértice y volcarlo en points.
function createStar(cx, cy, spikes, outerR, innerR) {
let points = "";
const step = Math.PI / spikes;
for (let i = 0; i < 2 * spikes; i++) {
const r = i % 2 === 0 ? outerR : innerR;
const x = cx + r * Math.cos(i * step);
const y = cy + r * Math.sin(i * step);
points += `${x},${y} `;
}
const polygon = document.createElementNS("http://www.w3.org/2000/svg", "polygon");
polygon.setAttribute("points", points.trim());
polygon.setAttribute("stroke", "#000");
polygon.setAttribute("fill", "transparent");
svg.appendChild(polygon);
}
Transformaciones y sistemas de coordenadas
SVG permite combinar translate, rotate y scale mediante el atributo transform. El reto fue obtener la caja delimitadora (bounding box) de la figura seleccionada teniendo en cuenta la diferencia entre coordenadas locales y globales. Utilicé getScreenCTM() para convertir todo al sistema global antes de calcular el rectángulo.
Ejemplo con la transformación aplicada
function getTransformedBBox(element) {
const bbox = element.getBBox();
const matrix = element.getScreenCTM();
const points = [
svg.createSVGPoint(), svg.createSVGPoint(),
svg.createSVGPoint(), svg.createSVGPoint()
];
points[0].x = bbox.x; points[0].y = bbox.y;
points[1].x = bbox.x + bbox.width; points[1].y = bbox.y;
points[2].x = bbox.x; points[2].y = bbox.y + bbox.height;
points[3].x = bbox.x + bbox.width; points[3].y = bbox.y + bbox.height;
return points.map(p => p.matrixTransform(matrix));
}
Con ello, incluso tras rotaciones o escalados pude dibujar correctamente el marco de selección.
Ajuste a rejilla (snap) y grilla
La rejilla se dibuja en el fondo con <pattern>. El ajuste se resuelve calculando coordenadas en JavaScript y redondeándolas al intervalo configurado.
function snapToGrid(value, gridSize) {
return Math.round(value / gridSize) * gridSize;
}
El ajuste a otros objetos recorre centros y extremos de las figuras existentes para localizar el punto más cercano, mostrar guías y fijar el objeto. Esto elevó notablemente la precisión de la UI.
Edición de texto
Como <text> no admite edición directa, superpuse temporalmente un <input> de HTML para editar en línea.
function editTextElement(textElem) {
const input = document.createElement("input");
input.type = "text";
input.value = textElem.textContent;
document.body.appendChild(input);
const bbox = textElem.getBoundingClientRect();
input.style.position = "absolute";
input.style.left = bbox.x + "px";
input.style.top = bbox.y + "px";
input.focus();
input.addEventListener("blur", () => {
textElem.textContent = input.value;
document.body.removeChild(input);
});
}
Trazados y curvas libres
<path> combina comandos como M, L, C o A para dibujar. Empecé con edición basada en líneas rectas, sumando coordenadas con cada clic.
let pathData = "M100,100";
function addPathPoint(x, y) {
pathData += ` L${x},${y}`;
path.setAttribute("d", pathData);
}
Exportación (SVG/PNG)
Al guardar elimino los elementos auxiliares y exporto. La conversión a PNG pasa por un canvas.
function exportToPNG(svgElement) {
const serializer = new XMLSerializer();
const source = serializer.serializeToString(svgElement);
const img = new Image();
const svgBlob = new Blob([source], { type: "image/svg+xml;charset=utf-8" });
const url = URL.createObjectURL(svgBlob);
img.onload = () => {
const canvas = document.createElement("canvas");
canvas.width = img.width;
canvas.height = img.height;
const ctx = canvas.getContext("2d");
ctx.drawImage(img, 0, 0);
canvas.toBlob(blob => {
const a = document.createElement("a");
a.href = URL.createObjectURL(blob);
a.download = "drawing.png";
a.click();
});
};
img.src = url;
}
Soporte de desplazamiento en el lienzo
Para manejar SVG grandes, envolví el lienzo con <div style="overflow:auto"> y, cuando es necesario, muestro barras de desplazamiento.
Conclusión
La especificación SVG es poderosa, pero la implementación tropieza con obstáculos como la conversión de coordenadas o la definición de trazados. En este editor logré ordenar esos frentes y cubrir:
- Manejo de atributos de figuras (
rect,ellipse,polygon,path). - Uso correcto de
transformy de los sistemas de coordenadas. - Implementación de rejilla y ajustes (snap).
- Edición de texto en línea.
- Edición de trazados basados en líneas.
- Exportación a SVG y PNG.
- Soporte para lienzos grandes desplazables.
Así pude construir un editor potente que explota al máximo las capacidades de SVG y funciona íntegramente en el navegador.