The Complete Production SOP: How to Deploy and Run Konva & react-konva High-Performance Canvas Stage in Autonomous AI Agents

---
name: "konva-react-canvas-shapes"
description: "Build high-performance 2D diagramming tools and games with react-konva."
metadata:
  author: "Anton Lavrenov"
  version: "1.0.0"
  runtime_compatibility:
    - "codex"
    - "claude-code"
    - "cursor"
    - "windsurf"
triggers:
  - "create react-konva stage"
  - "add transformer handles konva"
  - "drag and drop canvas shape konva"
permissions:
  fs_read: true
  fs_write: "workspace"
  shell_exec: false
  net_access: false
---

# Konva & react-konva High-Performance Canvas Stage

Manages multi-layer 2D canvas stages using Konva / react-konva: Stage, Layer, FastLayer, Shape components, Transformer selection handles, drag-and-drop, and high-DPI scaling.

## When to Invoke
Invoke this skill whenever you need to:
- create react-konva stage
- add transformer handles konva
- drag and drop canvas shape konva

## Execution SOP & Rules
1. Structure components: <Stage width={800} height={600}><Layer>...</Layer></Stage>.
2. Attach draggable prop on shapes: <Rect draggable onDragEnd={handleDragEnd} />.
3. Separate static background artwork onto a separate Layer to prevent unnecessary redraws.
4. Bind <Transformer ref={trRef} /> to active node references to provide interactive resize handles.

## Verification Checklist
- Run local linting, syntax validation, and type-checks before reporting completion.
- Ensure all created or modified files adhere to workspace boundaries and avoid uncommitted secrets.
- Verify tests or build commands exit cleanly with return code 0.

'use client';

import React, { useState, useRef, useEffect } from 'react';
import { Stage, Layer, Rect, Transformer } from 'react-konva';
import type Konva from 'konva';

interface ShapeConfig {
  id: string;
  x: number;
  y: number;
  width: number;
  height: number;
  fill: string;
}

export const InteractiveCanvas: React.FC = () => {
  const [shapes, setShapes] = useState<ShapeConfig[]>([
    { id: 'rect-1', x: 50, y: 50, width: 120, height: 80, fill: '#3b82f6' }
  ]);
  const [selectedId, setSelectedId] = useState<string | null>(null);
  const shapeRefs = useRef<Map<string, Konva.Rect>>(new Map());
  const trRef = useRef<Konva.Transformer | null>(null);

  useEffect(() => {
    if (!trRef.current) return;
    if (selectedId && shapeRefs.current.has(selectedId)) {
      const node = shapeRefs.current.get(selectedId)!;
      trRef.current.nodes([node]);
      trRef.current.getLayer()?.batchDraw();
    } else {
      trRef.current.nodes([]);
      trRef.current.getLayer()?.batchDraw();
    }
  }, [selectedId]);

  return (
    <Stage width={800} height={600} className="border border-slate-300 rounded">
      {/* Static Background Layer */}
      <Layer listening={false}>
        <Rect x={0} y={0} width={800} height={600} fill="#f8fafc" />
      </Layer>
      {/* Dynamic Interactive Layer */}
      <Layer>
        {shapes.map((s) => (
          <Rect
            key={s.id}
            id={s.id}
            ref={(node) => {
              if (node) shapeRefs.current.set(s.id, node);
              else shapeRefs.current.delete(s.id);
            }}
            x={s.x}
            y={s.y}
            width={s.width}
            height={s.height}
            fill={s.fill}
            draggable
            onClick={() => setSelectedId(s.id)}
            onTap={() => setSelectedId(s.id)}
            onDragEnd={(e) => {
              setShapes(prev => prev.map(item => item.id === s.id ? { ...item, x: e.target.x(), y: e.target.y() } : item));
            }}
          />
        ))}
        <Transformer ref={trRef} boundBoxFunc={(oldBox, newBox) => (newBox.width < 10 || newBox.height < 10 ? oldBox : newBox)} />
      </Layer>
    </Stage>
  );
};