Agent Zero
695 lines
54 KiB
Markdown
695 lines
54 KiB
Markdown
# web-cad v2.0 — ROADMAP & ARBEITSANWEISUNGEN
|
||
|
||
> **Dies ist die Steuerdatei für den Umbau.** Sie enthält Status, Zielarchitektur (Frontend + Backend), Regeln und exakte Arbeitsaufträge (Tasks).
|
||
> Bei jedem Fortschritt: Task-Status hier aktualisieren + Eintrag in Teil 7 (Fortschritts-Log).
|
||
>
|
||
> 📎 Hintergrund & Begründungen der Architektur-Entscheidungen: siehe [umbauplan-v2.md](./umbauplan-v2.md) — bei Abweichungen gilt DIES Dokument.
|
||
>
|
||
> Stand: 2026-08-26 · Basis: main @ `126277a` · Planer: Agent Zero · Umsetzung: Agent(en) beliebiger Stärke
|
||
|
||
---
|
||
|
||
# TEIL 0 — Wie du als Agent dieses Dokument abarbeitest
|
||
|
||
Du (Agent) arbeitest IMMER GENAU EINEN Task gleichzeitig ab. Verfahre so:
|
||
|
||
1. **Nächsten Task finden:** Gehe zu Teil 5. Nimm den ERSTEN Task mit `- [ ]` (offen), dessen „Voraussetzungen“ alle `- [x]` sind. Bearbeite Tasks niemals parallel oder in falscher Reihenfolge.
|
||
2. **Task lesen:** Lies den kompletten Task. Verstanden? Wenn nein: Frage den Nutzer, rate nicht.
|
||
3. **Ist-Zustand prüfen:** Öffne alle unter „Dateien“ genannten bestehenden Dateien und lies sie (zumindest die relevanten Abschnitte), BEVOR du etwas änderst.
|
||
4. **Schritte ausführen:** Folge „Schritte“ von oben nach unten. Führe nach jedem Schritt das dort genannte Verify-Kommando aus (falls angegeben).
|
||
5. **Fehlerfall:** Wenn ein Schritt fehlschlägt: maximal 3 gezielte Fix-Versuche. Danach: Änderungen des Schritts zurücksetzen (`git checkout -- <datei>` bzw. `git restore`), Task-Status auf `BLOCKIERT` setzen und Blockgrund in Teil 7 loggen. Weiter mit einem anderen unabhängigen Task ist erlaubt, wenn dessen Voraussetzungen erfüllt sind.
|
||
6. **Scope-Disziplin:** Ändere NIEMALS Dateien oder Verhalten, die der Task nicht nennt. Keine „Verbesserungen am Rande“. Wenn dir während der Arbeit ein anderes Problem auffällt: notiere es in Teil 7 unter „Gefundene Nebenprobleme“, behebe es NICHT jetzt.
|
||
7. **Abschluss eines Tasks:**
|
||
a. Führe ALLE Kommandos unter „Verify“ aus. Alles muss grün sein.
|
||
b. Commit: `git add -A && git commit -m "task(<TASK-ID>): <kurze beschreibung>"`.
|
||
c. Setze in diesem Dokument `- [ ]` → `- [x]` mit Datum und Commit-Hash.
|
||
d. Ergänze Teil 7 (Log): Datum, Task-ID, was getan wurde, Testergebnis, Commit-Hash, offene Punkte.
|
||
8. **Commit-Disziplin:** Ein Task = mindestens ein Commit. Nie halbfertigen Code committen, der `tsc` oder Tests bricht.
|
||
9. **Nie tun:** Dependencies entfernen, die du nicht selbst hinzugefügt hast · Datenbankschema ändern ohne Migrationsscript · Tests löschen oder überspringen (`skip`, `todo`) um grün zu werden · Secrets committen.
|
||
|
||
---
|
||
|
||
# TEIL 1 — Projektstatus & Baseline (Ist-Stand)
|
||
|
||
## 1.1 Was existiert (verifiziert am 2026-08-26)
|
||
|
||
| Bereich | Fakten |
|
||
|---|---|
|
||
| Repo | Forgejo `Leopoldadmin/web-cad`, Branch `main`, ~35.000 LOC |
|
||
| Frontend | React 18 + TS + Vite, Canvas 2D. `src/` ~16.480 LOC. `tsc --noEmit` = Exit 0 |
|
||
| Tests FE | 16 Dateien, 380 Tests, alle grün (`npx vitest run`) |
|
||
| Backend | Fastify + SQLite (better-sqlite3), 13 Route-Module, Auth (bcrypt, 4 Rollen), y-leveldb |
|
||
| Tests BE | 17 Dateien, 255 Tests, alle grün |
|
||
| Kollaboration | Yjs CRDT + WebSocket + y-indexeddb (Offline) |
|
||
| Deployment | Docker Compose, Coolify, Forgejo CI vorhanden |
|
||
|
||
## 1.2 Bekannte Bugs (müssen in Phase B gefixt werden)
|
||
|
||
| ID | Ort | Bug |
|
||
|---|---|---|
|
||
| BUG-1 | `frontend/src/services/seatingService.ts` (~L220) | `rowId: row_${Date.now()}` → ID-Kollisionen bei schneller Folge. Blöcke setzen gar keine rowId pro Reihe. `countSeats(byRow)` dadurch falsch. |
|
||
| BUG-2 | `frontend/src/tools/modification/geometry.ts` (~L303) | `findIntersection()` kann nur Gerade×Gerade → Trim/Extend/Fillet scheitern still auf Kreis/Bogen/Polyline. |
|
||
| BUG-3 | `frontend/src/interaction/index.ts` (handleModifyDown, offset-Zweig) | Offset nutzt nur Distanz, ignoriert Richtung des zweiten Klicks (Seite fehlt). |
|
||
| BUG-4 | `frontend/src/canvas/RenderEngine.ts` (`drawBackground`) | Hintergrundbild wird bei jedem Frame neu geladen (`img.onload = () => this.render()`). Muss gecacht werden. |
|
||
|
||
## 1.3 Architektur-Schwächen (Motivation für Umbau)
|
||
|
||
| Schwäche | Ort | Folge |
|
||
|---|---|---|
|
||
| God-Component | `App.tsx` (1803 LOC, 40+ useState) | Unwartbar, jede Mausbewegung (`cursorPos` in State) rendert GANZE App neu |
|
||
| Hart codierte Tools | `interaction/index.ts` (1157 LOC switch-case) | Werkzeuge nicht als Plugins möglich, Ribbon statisch |
|
||
| Snapshot-History | `history/HistoryManager.ts` | Ganzzustand-Undo, kollisionsanfällig in Kollaboration, keine Tool-Transaktionen |
|
||
| Direkte Engine-Kopplung | `components/CanvasArea.tsx` (477 LOC) | Renderer nicht austauschbar |
|
||
| Renderer Canvas2D only | `canvas/RenderEngine.ts` (1196 LOC) | 50k+ Elemente unrealistisch |
|
||
| DXF mini | `services/dxfParser.ts` (186 LOC), `dxfWriter.ts` (214 LOC) | Nur 7 Entity-Typen; ELLIPSE/SPLINE/MTEXT/HATCH/POINT fehlen |
|
||
|
||
## 1.4 Zielbild v2.0 (kurz)
|
||
|
||
Web-2D-CAD in Standard-CAD-Breite mit Event-Fokus. **Alle Werkzeuge = Plugins.** WebGL-Rendering. Library first-class, durch Plugin-Kataloge erweiterbar. Branchenneutral einsetzbar (Grundrisse, Gelände). Bedienmodi „Einfach“ und „Pro“. Frontend und Backend werden beide umgebaut.
|
||
|
||
---
|
||
|
||
# TEIL 2 — ZIELARCHITEKTUR FRONTEND (ausgearbeitet)
|
||
|
||
## 2.1 Neue Ordnerstruktur (Ziel)
|
||
|
||
```
|
||
frontend/src/
|
||
├── kernel/ # Framework-frei, kein React-Import erlaubt!
|
||
│ ├── model/ # Typen + Fabriken: CADElement, CADLayer, BlockDef, ids.ts
|
||
│ ├── geometry/ # intersects.ts (Line/Circle/Arc/Poly), transform.ts, bbox.ts
|
||
│ ├── document/ # CADDocument: CRUD + Queries über Yjs-Daten
|
||
│ └── history/ # Transaktionen (Wrapper um Yjs UndoManager)
|
||
├── render/
|
||
│ ├── types.ts # RenderAdapter-Interface + Viewport/Style-Typen
|
||
│ ├── pixi/ # PixiJS-Implementierung
|
||
│ │ ├── PixiRenderer.ts # implements RenderAdapter
|
||
│ │ ├── ElementLayer.ts # Graphics/Sprites pro CAD-Layer
|
||
│ │ ├── OverlayLayer.ts # Selection, Snaps, Previews, Tool-Overlays
|
||
│ │ ├── GridRulerLayer.ts
|
||
│ │ └── atlas.ts # Texturatlas für chair/table/stage
|
||
│ └── mock/MockAdapter.ts # Headless-Adapter für Unit-Tests (zeichnet nichts, protokolliert Aufrufe)
|
||
├── interaction/
|
||
│ ├── dispatcher.ts # InteractionDispatcher: DOM-Events → aktives Tool
|
||
│ ├── session.ts # ToolSession-Zustandsmaschine (idle/drawing/modifying)
|
||
│ ├── pointer.ts # Event-Normalisierung (screen→world, Buttons, Modifier)
|
||
│ └── shortcuts.ts # Tastatur-Mapping
|
||
├── plugins/
|
||
│ ├── types.ts # API v2 (siehe 2.4)
|
||
│ ├── registry.ts # Registry v2
|
||
│ ├── context.ts # PluginContext-Fabrik (Permissions geprüft)
|
||
│ ├── builtin/
|
||
│ │ ├── core-drawing/index.ts
|
||
│ │ ├── core-modify/index.ts
|
||
│ │ ├── core-annotate/index.ts
|
||
│ │ ├── core-measure/index.ts
|
||
│ │ └── event-tools/index.ts
|
||
│ └── library/ # LibraryProviderExtension-Verwaltung
|
||
├── stores/ # zustand Stores (NEU, ersetzt großen Teil des App-State)
|
||
│ ├── docStore.ts # Bindung an Yjs: elements/layers/selection (Selektion NICHT in Yjs, pro User lokal)
|
||
│ ├── toolStore.ts # activeToolId, toolOptions-Werte
|
||
│ ├── viewStore.ts # zoom, pan, grid, ortho, snap, unit, scaleFactor
|
||
│ └── uiStore.ts # panels, modals, ribbonTab, mode: 'simple'|'pro'
|
||
├── ui/
|
||
│ ├── AppShell.tsx # NUR Layout (Grid aus Slots)
|
||
│ ├── canvas/CanvasHost.tsx # Mountet Kernel+Renderer+Dispatcher, sonst nichts
|
||
│ ├── ribbon/RibbonBar.tsx # dynamisch aus pluginRegistry.getToolExtensions()
|
||
│ ├── panels/… # LeftSidebar, RightSidebar, PropertiesPanel (liest toolOptions-Schema)
|
||
│ ├── dialogs/…
|
||
│ └── simple/… # Einfach-Modus Varianten
|
||
├── services/ # bleiben (api.ts, import/export, background, seating → wandert teils in plugins/builtin/event-tools/domain)
|
||
├── crdt/ # bleibt (YjsDocument etc.)
|
||
└── types/ # cad.types.ts bleibt Quelle der Wahrheit für Persistenz-Typen
|
||
```
|
||
|
||
**Regel:** `kernel/**` darf React nirgends importieren. `render/pixi/**` kennt keine React-Components. React kennt Renderer nur über `CanvasHost`.
|
||
|
||
## 2.2 State-Management (Entscheidung + Begründung)
|
||
|
||
**Neu: zustand** (klein, kein Provider-Boilerplate, selektierbar).
|
||
|
||
Gründe gegen Ist-Zustand:
|
||
- `cursorPos` liegt heute in App-State → jede Mausbewegung re-rendert 1803-LOC-Tree. Neu: Cursor-Anzeige liest Position aus einem throttled store-Slice ODER direkt DOM-Update im CanvasHost (bevorzugt: StatusBar subscribed auf `viewStore.cursor` mit Selektor; Update max 60/s).
|
||
- Elemente liegen doppelt (React-State UND Yjs). Neu: **Yjs ist alleinige Quelle der Wahrheit**. `docStore` spiegelt Yjs-Arrays in einen zustand-Slice (via `yjs.observe`), Components lesen daraus. Kein zweites `setElements`.
|
||
|
||
Store-Verträge (exakt):
|
||
|
||
```ts
|
||
// stores/docStore.ts
|
||
interface DocSlice {
|
||
elements: Record<string, CADElement>; // id → element (Spiegel von Yjs Map)
|
||
elementOrder: string[]; // Render-/Auswahlreihenfolge
|
||
layers: CADLayer[];
|
||
selection: string[]; // lokale Selektion (nicht synchronisiert)
|
||
setSelection(ids: string[]): void;
|
||
}
|
||
// stores/toolStore.ts
|
||
interface ToolSlice {
|
||
activeToolId: string; // default 'select'
|
||
optionValues: Record<string, Record<string, unknown>>; // toolId → optionKey → value
|
||
setTool(id: string): void; // validiert gegen Registry
|
||
setOption(toolId: string, key: string, value: unknown): void;
|
||
}
|
||
```
|
||
|
||
## 2.3 Rendering-Pipeline (Ziel)
|
||
|
||
Frame-Zyklus (außerhalb React):
|
||
1. `InteractionDispatcher` erhält DOM-Event → normalisiert (`pointer.ts`) → ruft Handler des aktiven Tools mit Weltkoordinaten.
|
||
2. Tool ändert Entweder: a) `document.transact(fn)` (committed, erzeugt Undo-Eintrag) oder b) `renderer.setPreview(el)` (nur Optik).
|
||
3. `PixiRenderer` hält pro CAD-Layer einen Container. Bei Yjs-Transaktion: diff-basiertes Update (added/removed/changed Keys aus Yjs-Events), KEIN Full-Redraw.
|
||
4. Overlays (Selection/Snap/Preview) leben in eigenem Layer, immer neu zeichnbar ohne Element-Layer zu berühren.
|
||
5. requestAnimationFrame-Loop rendert nur bei `dirty`-Flag (kein Dauerloop).
|
||
|
||
Performance-Ziele (messbar in `tests/PerformanceBenchmark.test.ts` weiterführen):
|
||
- 10k Elemente: Interaktion < 50ms Latenz
|
||
- 50k Chairs (Atlas-instanziiert): ≥ 55fps bei Pan/Zoom auf Referenzhardware
|
||
- Erstzeichnung Dashboard→Canvas sichtbar < 2s
|
||
|
||
## 2.4 Plugin-API v2 (Vertrag, exakte Interfaces)
|
||
|
||
```ts
|
||
// plugins/types.ts (NEU, ersetzt Teile der alten API)
|
||
export interface ToolManifestPart {
|
||
id: string; label: string; icon: string; ribbonTab: string;
|
||
shortcut?: string; tags?: ('basic'|'pro')[]; // 'basic' = im Einfach-Modus sichtbar
|
||
}
|
||
export interface ToolPointerEvent { world: Pt; screen: Pt; button: number; shift: boolean; alt: boolean; ctrl: boolean; }
|
||
export interface ToolContext {
|
||
doc: CADDocument; // CRUD + transact()
|
||
renderer: RenderAdapter; // für Preview/Overlay
|
||
snap: SnapEngine; selection: SelectionEngine;
|
||
options: Record<string, unknown>; // aktuelle OptionValues
|
||
setStatus(msg: string): void; // Statuszeile
|
||
}
|
||
export interface ToolExtensionV2 {
|
||
manifest: ToolManifestPart & { description?: string };
|
||
optionsSchema: PropertyField[]; // existierender Typ wiederverwendet
|
||
handlers: {
|
||
down?(e: ToolPointerEvent, ctx: ToolContext): void;
|
||
move?(e: ToolPointerEvent, ctx: ToolContext): void;
|
||
up?(e: ToolPointerEvent, ctx: ToolContext): void;
|
||
key?(e: KeyboardEvent, ctx: ToolContext): boolean; // true = konsumiert
|
||
cancel?(ctx: ToolContext): void; // ESC
|
||
};
|
||
}
|
||
export interface PanelExtension { id: string; title: string; slot: 'left'|'right'; render(): HTMLElement; }
|
||
export interface LibraryProviderExtension {
|
||
id: string; label: string;
|
||
listFolders(): Promise<LibFolder[]>;
|
||
listBlocks(folderId: string): Promise<LibBlock[]>;
|
||
getBlock(id: string): Promise<LibBlock>;
|
||
}
|
||
export interface PluginV2 {
|
||
manifest: { id; name; version; author; description; category: 'tools'|'elements'|'library'|'import-export'|'theme'|'other';
|
||
enabledByDefault?: boolean; minAppVersion?: string; permissions?: Array<'canvas'|'network'|'storage'> };
|
||
tools?: ToolExtensionV2[];
|
||
commands?: CommandExtension[]; // existiert bereits, unverändert
|
||
elementTypes?: ElementTypeExtension[]; // bleibt, render optional + renderPixi später
|
||
panels?: PanelExtension[];
|
||
libraryProviders?: LibraryProviderExtension[];
|
||
onInit?(ctx: PluginContext): void; onActivate?(); onDeactivate?(); onDestroy?();
|
||
}
|
||
```
|
||
|
||
Migration Alt→Neu (wichtig!):
|
||
- Alte `ToolExtension {onActivate}` bleibt ÜBERGANGSWEISE bestehen (Phase A kompatibel), wird in A3 migriert und DANACH entfernt.
|
||
- `InteractionEngine.setTool(id)` delegiert ab A2 ausschließlich an Registry-Tools.
|
||
|
||
## 2.5 Undo/Redo (Entscheidung)
|
||
|
||
**Yjs `Y.UndoManager` verwenden**, eigenes Snapshot-History entfernen (Phase A4).
|
||
- Eine Tool-Aktion = eine `doc.transact(...)` = ein Undo-Schritt. Kollaborativ korrekt (undoed nur eigene Ops).
|
||
- `HistoryPanel` liest `undoManager.undoStack.length` etc.
|
||
- Alte `HistoryManager`-Tests (32) werden auf neue Transaktions-API umgeschrieben (Aufwand ~0,5 Tag, in A4 eingeplant).
|
||
|
||
## 2.6 Bedienmodi
|
||
|
||
- `uiStore.mode: 'simple'|'pro'`. Default für neue Nutzer: `simple`.
|
||
- Filter: Ribbon zeigt Tool nur, wenn `mode==='pro' || manifest.tags.includes('basic')`. CommandLine/Layer-Tiefe nur pro.
|
||
- Umschalter: Topbar-Menü + SettingsModal. Persistenz in usersettings (Backend, existierende settings-Route nutzen).
|
||
|
||
---
|
||
|
||
# TEIL 3 — ZIELARCHITEKTUR BACKEND (Kurzfassung)
|
||
|
||
Bleibt Fastify + SQLite. Neuerungen:
|
||
- Tabellen: `plugins(id TEXT PK, version TEXT, enabled_default INT, installed_at TEXT)`; `plugin_settings(plugin_id TEXT, scope TEXT, scope_id TEXT, json TEXT, PRIMARY KEY(plugin_id,scope,scope_id))`; `library_folders(id TEXT PK, parent_id TEXT, name TEXT, owner_scope TEXT)`; `library_blocks(id TEXT PK, folder_id TEXT, name TEXT, tags TEXT, thumbnail TEXT, attr_defs TEXT, payload TEXT, source TEXT)`; `guests(id TEXT PK, project_id TEXT, name TEXT, seat_id TEXT NULL)` (Phase E6, optional 2.1).
|
||
- Routen neu: `/api/plugins` GET · `/api/plugins/:id/settings` GET/PUT · `/api/plugins/install` POST (Admin, ZIP) · `/api/library/folders|blocks` CRUD · `/api/library/import|export` POST.
|
||
- WebSocket-Notify: `pluginStateChanged`, `libraryChanged` Broadcast.
|
||
- Migrationsmechanismus: `backend/src/database/migrations/NNNN_name.sql`, Runner beim Boot (Schema-Versionstabelle). JEDE Schemaänderung mit Migrationsfile + Test.
|
||
|
||
---
|
||
|
||
# TEIL 4 — REGELN (Definition of Done)
|
||
|
||
Ein Task ist nur dann fertig, wenn ALLSES gilt:
|
||
1. `cd frontend && npx tsc --noEmit` → Exit 0.
|
||
2. `cd frontend && npx vitest run` → alle Tests grün (Anzahl darf nie sinken; neue Features bringen Tests).
|
||
3. `cd backend && npx vitest run` → alle grün (bei Backend-Tasks).
|
||
4. Keine neuen `console.log` (Logger-Util `utils/logger.ts` nutzen, in A0 anlegen).
|
||
5. Neue öffentliche Funktionen/Interfaces haben TSDoc-Kommentar (1–3 Zeilen).
|
||
6. Commit-Format: `task(<ID>): <beschreibung>` (Conventional reicht so).
|
||
7. Dieser File: Status gesetzt + Log-Eintrag.
|
||
|
||
Testkonventionen:
|
||
- Neue Kernel-Module: Vitest Unit-Tests OHNE DOM (`environment: node` geht nicht global — lege pro Testfile `// @vitest-environment node` falls kein DOM nötig).
|
||
- Renderer: Tests laufen gegen `MockAdapter` (protokolliert draw*-Aufrufe). WebGL selbst wird nur in Playwright-Smoke getestet.
|
||
- Tools: je Tool ein Workflow-Test (down/move/up-Sequenz gegen MockAdapter + InMemory-Doc).
|
||
|
||
---
|
||
|
||
# TEIL 5 — PHASEN & TASKS
|
||
|
||
Legende: `- [ ]` offen · `- [~]` in Arbeit (Datum) · `- [x]` fertig (Datum, Hash) · `[BLOCKIERT: grund]`
|
||
|
||
**ERWEITERUNGSREGEL (verpflichtend):** Die Tasks in Phase C (ab C2) und den Phasen D–I sind bewusst als Kurz-Tasks gehalten. SOFORT VOR Beginn eines solchen Tasks wird er auf das volle Schema erweitert (Voraussetzungen · Ziel · Dateien · nummerierte Schritte mit Code-Ankerpunkten · Verify-Kommandos · Commit-Text) und die Erweiterung in diesem Dokument gespeichert. Ein Kurz-Task darf NIE direkt bearbeitet werden. Grund: Nur vollständig ausgeformte Tasks sind von einem schwachen Modell sicher ausführbar.
|
||
|
||
**COPY-PASTE-REGEL:** Wo ein Task kompletten Code enthält (z.B. B0-Testdatei): exakt übernehmen, NICHT „verbessern“. Eigene Abweichungen nur, wenn ein Schritt nachweislich am Ist-Code scheitert – dann Blockierung gemäß Teil 0 Punkt 5 loggen.
|
||
|
||
## Phase B — Bugfixes (zuerst! klein & isoliert)
|
||
|
||
### Task B0 — Testgerüst für Bugs (ROT-Tests) ✅ [2026-08-26 · b9eb69f]
|
||
- Voraussetzungen: keine
|
||
- Ziel: Repro-Tests für BUG-1, BUG-1b und BUG-2, die HEUTE rot sind und nach den Fixes grün. (Regressionstests für BUG-3 liegen in Task B3, für BUG-4 in Task B4 — dort jeweils im selben Commit wie der Fix, weil sie vor dem Fix gegen die bestehende API nicht kompilierbar sind.)
|
||
- Dateien: NEU `frontend/tests/bugs.regress.test.ts`
|
||
|
||
**WICHTIG (verifiziert):** `findIntersection` ist in `geometry.ts` NICHT exportiert (nur intern genutzt). Der BUG-2-Test darf es deshalb NICHT importieren — er prüft über das exportierte `trimElement`. `SeatingService` ist exportiert (`export class SeatingService`, L162).
|
||
|
||
Erzeuge die Datei `frontend/tests/bugs.regress.test.ts` mit EXAKT diesem Inhalt:
|
||
|
||
```ts
|
||
/**
|
||
* Regressions-Tests für bekannte Bugs BUG-1, BUG-1b, BUG-2.
|
||
* Diese Tests sind VOR dem jeweiligen Fix ROT (dokumentiertes Fehlverhalten)
|
||
* und müssen danach GRÜN sein.
|
||
*/
|
||
import { describe, it, expect } from 'vitest';
|
||
import { SeatingService } from '../src/services/seatingService';
|
||
import { trimElement } from '../src/tools/modification/geometry';
|
||
import type { CADElement } from '../src/types/cad.types';
|
||
|
||
// ── Helfer (Muster aus tests/geometry.test.ts) ─────────────
|
||
function makeLine(id: string, x1: number, y1: number, x2: number, y2: number): CADElement {
|
||
return {
|
||
id,
|
||
type: 'line',
|
||
layerId: 'layer-1',
|
||
x: (x1 + x2) / 2,
|
||
y: (y1 + y2) / 2,
|
||
width: Math.abs(x2 - x1),
|
||
height: Math.abs(y2 - y1),
|
||
properties: { x1, y1, x2, y2 },
|
||
} as unknown as CADElement;
|
||
}
|
||
|
||
function makeCircle(id: string, cx: number, cy: number, r: number): CADElement {
|
||
return {
|
||
id,
|
||
type: 'circle',
|
||
layerId: 'layer-1',
|
||
x: cx,
|
||
y: cy,
|
||
width: r * 2,
|
||
height: r * 2,
|
||
properties: { radius: r },
|
||
} as unknown as CADElement;
|
||
}
|
||
|
||
// ── BUG-1: rowId-Kollision bei schnellem Erzeugen ───────────
|
||
describe('BUG-1: seating row ids', () => {
|
||
it('zwei direkt hintereinander erzeugte Reihen haben unterschiedliche rowIds', () => {
|
||
const svc = new SeatingService();
|
||
const a = svc.createSeatingRow(0, 0, 'layer-1');
|
||
const b = svc.createSeatingRow(0, 100, 'layer-1');
|
||
const ids = new Set([a[0].properties.rowId, b[0].properties.rowId]);
|
||
expect(ids.size).toBe(2);
|
||
});
|
||
});
|
||
|
||
// ── BUG-1b: Block-Reihen ohne eigene rowId ──────────────────
|
||
describe('BUG-1b: seating block row ids', () => {
|
||
it('jede Reihe eines Blocks hat eine eigene, definierte rowId', () => {
|
||
const svc = new SeatingService();
|
||
const els = svc.createSeatingBlock(0, 0, 'layer-1', { rows: 3, cols: 2 });
|
||
expect(els.length).toBe(6);
|
||
const rowIds = new Set(els.map((e) => e.properties.rowId));
|
||
expect(rowIds.size).toBe(3);
|
||
for (const rid of rowIds) expect(rid).toBeDefined();
|
||
});
|
||
});
|
||
|
||
// ── BUG-2: Trim an Kreis scheitert (findIntersection nur Gerade×Gerade) ──
|
||
describe('BUG-2: trim line at circle', () => {
|
||
it('trimElement(Linie, Kreis) liefert ein Ergebnis statt null', () => {
|
||
// Linie von (0,0) nach (200,0) schneidet Kreis (Zentrum 100,0, Radius 40)
|
||
// an x=60 und x=140 → Schnitt existiert eindeutig.
|
||
const line = makeLine('l1', 0, 0, 200, 0);
|
||
const circle = makeCircle('c1', 100, 0, 40);
|
||
const result = trimElement(line, circle);
|
||
expect(result).not.toBeNull();
|
||
});
|
||
});
|
||
```
|
||
|
||
Hinweis zu makeLine/makeCircle: Die properties-Namen (x1,y1,x2,y2 bzw. radius) sind die vom Produktivcode genutzten Konventionen (`findIntersection` liest x1..y2; `RenderEngine.drawCircle` liest `properties.radius || width/2`). Falls `tests/geometry.test.ts` abweichende Helfer hat, gleiche sie daran an — die Struktur oben bleibt.
|
||
|
||
- Schritte:
|
||
1. Datei exakt wie oben anlegen.
|
||
2. Ausführen: `cd frontend && npx vitest run tests/bugs.regress.test.ts` → ERWARTET: alle 3 Tests FAIL (das ist der Beweis, dass die Bugs real sind; dokumentiere die Fehlermeldungen kurz in Teil 7).
|
||
3. Gesamt-Suite: `npx vitest run` → alles andere muss grün bleiben, nur die 3 neuen Tests rot.
|
||
- Verify: `npx vitest run tests/bugs.regress.test.ts 2>&1 | tail -25` (3 fail erwartet) · `npx vitest run 2>&1 | tail -5` (nur diese 3 rot) · `npx tsc --noEmit` (Exit 0 — Tests müssen kompilieren!)
|
||
- Commit: `task(B0): regression tests for known bugs (red)`
|
||
- Nicht tun: Fixes schon einbauen · Tests mit `.skip` versehen · die roten Tests „reparieren"
|
||
|
||
### Task B1 — Seating-IDs fixen (BUG-1) ✅ [2026-08-26 · 1bbd653]
|
||
- Voraussetzungen: B0
|
||
- Dateien: `frontend/src/services/seatingService.ts`
|
||
- Schritte:
|
||
1. Direkt nach den Interface-/Default-Konstanten (vor `export class SeatingService`) diesen Helper ergänzen:
|
||
```ts
|
||
let seqCounter = 0;
|
||
function nextUid(prefix: string): string {
|
||
seqCounter += 1;
|
||
return `${prefix}_${Date.now().toString(36)}_${seqCounter.toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
|
||
}
|
||
```
|
||
(Prüfe zuerst mit grep, ob es bereits eine `generateId()`-Methode in der Klasse gibt — wenn ja, nutze diese für Element-IDs weiter, aber NICHT für rowId, da rowId pro Reihe gleich sein muss.)
|
||
2. In `createSeatingRow` (ca. L189): VOR der for-Schleife `const rowId = nextUid('row');` einfügen; innerhalb properties: `rowId: row_${Date.now()}` ERSETZEN durch `rowId,` (und `rowIndex: i` bleibt).
|
||
3. In `createSeatingBlock` (ca. L227): VOR der äußeren for-Schleife `const blockId = nextUid('block');` (ersetzt das bestehende `const blockId = \`block_${Date.now()}`). INNERHALB der äußeren Schleife (pro Reihe) `const rowId = nextUid('row');`; in properties ergänzen: `rowId,` (neu) neben bestehendem `blockId`, `rowIndex`, `colIndex`.
|
||
4. Ausführen: `npx vitest run tests/bugs.regress.test.ts` → BUG-1 und BUG-1b jetzt GRÜN; BUG-2 weiterhin rot (kommt in B2).
|
||
- Verify: `npx vitest run tests/bugs.regress.test.ts 2>&1 | tail -15` (2 von 3 grün) · `npx tsc --noEmit` Exit 0 · `npx vitest run 2>&1 | tail -5`
|
||
- Commit: `task(B1): unique row/block ids for seating (fixes BUG-1)`
|
||
|
||
### Task B2 — findIntersection erweitern (BUG-2)
|
||
- Voraussetzungen: B0
|
||
- Dateien: `frontend/src/tools/modification/geometry.ts`
|
||
- Schritte:
|
||
1. LESE ZUERST `RenderEngine.drawArc` (L524) und notiere dir die Arc-Property-Konvention (Felder + Winkeleinheit/Richtung). Nutze dieselbe Konvention in den neuen Funktionen.
|
||
2. Neue exportierte Funktionen in geometry.ts ergänzen:
|
||
```ts
|
||
export interface Pt { x: number; y: number; }
|
||
/** Alle Schnittpunkte Strecke p1→p2 × Kreis(c,r); NUR t∈[0,1] (echte Strecke). */
|
||
export function lineCircleIntersections(p1: Pt, p2: Pt, c: Pt, r: number): Pt[] {
|
||
// Standardformel: a=d·d, b=2·f·d, cc=f·f−r² mit d=p2−p1, f=p1−c
|
||
// t=(−b±√(b²−4ac))/(2a); nur t∈[0,1]; Diskriminante<0 → []
|
||
}
|
||
/** Schnittpunkte zweier Kreise; [] wenn getrennt oder identisch. */
|
||
export function circleCircleIntersections(c1: Pt, r1: number, c2: Pt, r2: number): Pt[] {
|
||
// Standardformel: d=|c2−c1|, Grenzfälle dokumentieren
|
||
}
|
||
/** Strecke × Bogen; Konvention wie RenderEngine.drawArc. */
|
||
export function lineArcIntersection(p1: Pt, p2: Pt, el: CADElement): Pt[] {
|
||
// 1) Strecke×Kreis via lineCircleIntersections
|
||
// 2) Treffer auf Winkel im [startAngle,endAngle]-Bereich filtern (Grad→Rad konvertieren)
|
||
}
|
||
```
|
||
3. findIntersection (intern, L303): Dispatch je Typkombination: line×line (bestehend), line×circle, line×arc, circle×circle; Reihenfolge egal → intern normalisieren (z.B. immer kleinerer Typname zuerst). Bei mehreren Punkten: der NAHERE zu p1 von Element 1.
|
||
4. trimElement/extendElement unverändert lassen.
|
||
5. Unit-Tests ERGÄNZEN in tests/geometry.test.ts (Datei NICHT ersetzen): je neuer Funktion ≥2 positiv, ≥1 negativ, Randfälle tangential (genau 1 Punkt) + sekant (2 Punkte). BUG-2-Test aus bugs.regress.test.ts muss grün werden.
|
||
- Verify: `npx vitest run tests/geometry.test.ts tests/bugs.regress.test.ts 2>&1 | tail -15` (alles grün inkl. BUG-2) · `npx vitest run 2>&1 | tail -5` · `npx tsc --noEmit`
|
||
- Commit: `task(B2): line/circle/arc intersections (fixes BUG-2)`
|
||
|
||
### Task B3 — Offset-Richtung (BUG-3)
|
||
- Voraussetzungen: B2 (nutzt Pt/Normalen-Helfer aus geometry.ts)
|
||
- Dateien: `frontend/src/tools/modification/geometry.ts`, `frontend/src/interaction/index.ts`, ERGÄNZEN `frontend/tests/bugs.regress.test.ts`
|
||
- Schritte:
|
||
1. geometry.ts: Signatur ändern zu `export function offsetElement(el: CADElement, dist: number, side?: 1 | -1): CADElement` — `dist` wird mit `(side ?? 1)` multipliziert. Prüfe ALLE bestehenden Aufrufer (`grep -n 'offsetElement(' -r src tests`): Bestehende Aufrufe ohne drittes Argument müssen unverändert weiterlaufen (Default side=1). Normale für line: (-dy, dx)/len; für rect/circle: Vorzeichen relativ zum Zentrum vs. Klickpunkt (wird vom Aufrufer übergeben).
|
||
2. interaction/index.ts offset-Zweig (handleModifyDown): berechne `side` per Kreuzprodukt: `cross = (p2.x-p1.x)*(pt.y-p1.y) - (p2.y-p1.y)*(pt.x-p1.x)`; `const side = cross >= 0 ? 1 : -1`; übergebe `offsetElement(this.modifySelected[0], dist, side)`. p1/p2 = Endpunkte der Basislinie aus properties (x1,y1,x2,y2); bei rect/circle: Klickpunkt vs. Elementzentrum.
|
||
3. Regressionstest in bugs.regress.test.ts ERGÄNZEN:
|
||
```ts
|
||
describe('BUG-3: offset respects click side', () => {
|
||
it('Klick links der Linie versetzt nach links', () => {
|
||
// Linie (100,100)→(300,100), Klick bei (200,50) = oberhalb → Ergebnis-Mitte.y < 100
|
||
});
|
||
});
|
||
```
|
||
(Konkret ausarbeiten: offsetElement(line, 20, -1) muss y um −20 verschieben, +1 um +20 — exakt eine Assertion auf resultierende properties.x1/y1.)
|
||
4. Suite grün inkl. neuem Test.
|
||
- Verify: `npx vitest run tests/bugs.regress.test.ts 2>&1 | tail -15` · `npx vitest run 2>&1 | tail -5` · `npx tsc --noEmit`
|
||
- Commit: `task(B3): offset respects click side (fixes BUG-3)`
|
||
|
||
### Task B4 — Hintergrundbild cachen (BUG-4)
|
||
- Voraussetzungen: B0
|
||
- Dateien: `frontend/src/canvas/RenderEngine.ts`, ERGÄNZEN `frontend/tests/bugs.regress.test.ts`
|
||
- Schritte:
|
||
1. LESE ZUERST die aktuelle `drawBackground()` (L381) komplett und verstehe den Transform-Kontext (ZoomPan-Transform ist beim Aufruf aktiv).
|
||
2. Zwei private Felder ergänzen:
|
||
```ts
|
||
private bgImage: HTMLImageElement | null = null;
|
||
private bgSrcLoaded = '';
|
||
```
|
||
3. drawBackground umschreiben: wenn `this.options.backgroundSrc && this.options.backgroundSrc !== this.bgSrcLoaded` → NEUES Image laden; onload: Felder setzen + EINMALIG `this.render()`; wenn `backgroundSrc === bgSrcLoaded && bgImage` → direkt `ctx.drawImage(...)` mit dem bestehenden Transform (kein Laden). Wenn backgroundSrc null/leer → Felder zurücksetzen.
|
||
4. Regressionstest in bugs.regress.test.ts ERGÄNZEN (jsdom liefert Mock-Context aus tests/setup.ts):
|
||
```ts
|
||
describe('BUG-4: background image cached', () => {
|
||
it('zweites render laedt das Bild nicht erneut', () => {
|
||
// RenderEngine instanziieren wie in tests/RenderEngine.test.ts (createMockCanvas-Muster)
|
||
// engine.setOptions({ backgroundSrc: 'data:image/png;base64,iVBORw0KGgo=' })
|
||
// engine.render(); await tick; engine.render();
|
||
// assert: nur 1× new Image() bzw. img.src-Zuweisung (spy via vi.spyOn(global, 'Image'))
|
||
});
|
||
});
|
||
```
|
||
Ausarbeiten mit vi.spyOn(window, 'Image') oder global.Image-Stub; Assertion: Konstruktor-Aufrufe === 1 nach zwei render()-Aufrufen mit gleicher src. Falls jsdom das nicht hergibt: Test auf privates Feld via `(engine as any).bgSrcLoaded` zulassen.
|
||
5. Suite grün inkl. neuem Test.
|
||
- Verify: `npx vitest run tests/bugs.regress.test.ts 2>&1 | tail -15` · `npx vitest run 2>&1 | tail -5` · `npx tsc --noEmit`
|
||
- Commit: `task(B4): cache background image (fixes BUG-4)`
|
||
|
||
### Task B5 — countSeats robust (folgt aus B1)
|
||
- Voraussetzungen: B1
|
||
- Dateien: `frontend/src/services/seatingService.ts`
|
||
- Schritte: `countSeats` byRow: Gruppierung nach `rowId` unabhängig ob block oder row; byBlock zusätzlich; Rückgabetyp erweitern `{total, byRow, byBlock, byZone?}` (byZone optional leer lassen). Test in `tests/` ergänzen (neues File `seating.count.test.ts`).
|
||
- Verify: volle Suite grün. Commit `task(B5): seat counting by row and block`
|
||
|
||
## Phase A — Plugin-first Kernel (nach B; A und C können ab A2 parallel)
|
||
|
||
### Task A0 — Logger + Testhelfer
|
||
- Voraussetzungen: B5
|
||
- Dateien: NEU `frontend/src/utils/logger.ts` (level-gesteuert, noop in prod-build via vite define), NEU `frontend/tests/helpers/mockAdapter.ts` (MockAdapter: implementiert RenderAdapter-Interface als Recorder — Interface kommt in C1, Mock implementiert zunächst NUR die Methoden, die InteractionEngine heute braucht: preview/clear/snapPoints; wird in C1 erweitert), NEU `frontend/tests/helpers/inMemoryDoc.ts` (dünner Wrapper um YjsDocument ohne Netzwerk).
|
||
- Schritte: Dateien anlegen, je 1 Smoke-Test (`logger writes in test env`, `mock records calls`).
|
||
- Verify: `npx vitest run tests/helpers` grün. Commit `task(A0): logger and test helpers`
|
||
|
||
### Task A1 — Plugin-Typen v2 + Registry-Erweiterung ( additive )
|
||
- Voraussetzungen: A0
|
||
- Dateien: `frontend/src/plugins/types.ts` (ERWEITERN, nichts Entfernen), `frontend/src/plugins/PluginRegistry.ts` (neue Getter), NEU `frontend/plugins-v2.test.ts`→ besser `frontend/tests/pluginApiV2.test.ts`
|
||
- Schritte:
|
||
1. Types aus TEIL 2.4 exakt übernehmen (ToolExtensionV2, PanelExtension, LibraryProviderExtension, PluginV2, ToolPointerEvent, ToolContext). Alte Typen bleiben.
|
||
2. Registry: `registerV2(p: PluginV2)`, `getToolsV2(): ToolExtensionV2[]`, `getPanels()`, `getLibraryProviders()`. enable/disable analog alt (state map um version erweitern).
|
||
3. Tests: Register/enable/disable/getters; doppelte ID verworfen; disabled Tools tauchen in getToolsV2 nicht auf.
|
||
- Verify: suite grün. Commit `task(A1): plugin api v2 types and registry (additive)`
|
||
|
||
### Task A2 — InteractionDispatcher (parallel zu Altlaufwerk, hinter Feature-Flag)
|
||
- Voraussetzungen: A1
|
||
- Dateien: NEU `frontend/src/interaction/dispatcher.ts`, NEU `frontend/src/interaction/session.ts`, NEU `frontend/src/interaction/pointer.ts`, ÄNDERN `frontend/src/components/CanvasArea.tsx` (Flag), ÄNDERN `frontend/src/types/ui.types.ts` (Flag-Typ)
|
||
- Schritte:
|
||
1. pointer.ts: `toWorld(e: PointerEvent, zoomPan): ToolPointerEvent` (screenToWorld nutzen), Button/Modifier mappen, `setPointerCapture` Helfer.
|
||
2. session.ts: `class ToolSession { phase:'idle'|'active'; begin(); end(); }` minimal.
|
||
3. dispatcher.ts: `class InteractionDispatcher { constructor(canvas, deps{zoomPan,doc,renderer,snap,selection}) ; setActive(toolId|null) }` — bindet pointerdown/move/up/keydown/Escape; ruft handlers des aktiven V2-Tools; ESC → cancel; Rechtsklick → cancel.
|
||
4. CanvasArea: Env-Flag `VITE_TOOL_DISPATCHER=v2` (vite env): wenn gesetzt → Dispatcher instanziieren und InteractionEngine deaktivieren (nur Konstruktion skippen), sonst alter Weg. Standard in .env.example dokumentieren.
|
||
5. Test: `dispatcher.test.ts` — synthetische PointerEvents auf Fake-Canvas (aus tests/setup.ts vorhanden?), assert handler-Reihenfolge down→move→up, ESC ruft cancel.
|
||
- Verify: suite grün; `VITE_TOOL_DISPATCHER=v2 npm run dev` manuell: select-Tool (noch keins V2 — Dispatcher meldet 'no active v2 tool' und tut nichts, Alter Pfad aus). Commit `task(A2): tool dispatcher behind flag`
|
||
|
||
### Task A2b — CADDocument mit transact + UndoManager (Grundlage für Tools)
|
||
- Voraussetzungen: A1
|
||
- Ziel: Eine dünne Dokument-Fassade über YjsDocument, die Tools in A3/A4 nutzen: CRUD + Transaktionen + Undo/Redo. KEINE Tool-Logik hier!
|
||
- Dateien: NEU `frontend/src/kernel/document/CADDocument.ts`, NEU `frontend/tests/cadDocument.test.ts`, LESEN `frontend/src/crdt/YjsDocument.ts`
|
||
- Schritte:
|
||
1. LESE YjsDocument.ts komplett: wie sind elements/layers gespeichert (Y.Map? Y.Array?), wie lauten die bestehenden Methodennamen?
|
||
2. CADDocument-Klasse anlegen:
|
||
```ts
|
||
/**
|
||
* Fassade über YjsDocument: elementar-CRUD + transaktionale Änderungen
|
||
* mit kollaborativ korrektem Undo via Y.UndoManager.
|
||
*/
|
||
export class CADDocument {
|
||
constructor(ydoc: YjsDocument) { ... }
|
||
addElement(el: CADElement): void;
|
||
updateElement(id: string, patch: Partial<CADElement>): void; // shallow merge in properties
|
||
deleteElements(ids: string[]): void;
|
||
getElement(id: string): CADElement | undefined;
|
||
getAllElements(): CADElement[];
|
||
getLayer(id: string): CADLayer | undefined;
|
||
getAllLayers(): CADLayer[];
|
||
/** Führt fn als EINE Transaktion aus → genau 1 Undo-Schritt. */
|
||
transact(fn: () => void): void; // ydoc.doc.transact(fn)
|
||
undo(): boolean; redo(): boolean; canUndo(): boolean; canRedo(): boolean;
|
||
onElementsChanged(cb: () => void): () => void; // subscribe, returns unsubscribe
|
||
}
|
||
```
|
||
3. UndoManager im Konstruktor: `new Y.UndoManager([elementsYType, layersYType])` (exakte Typnamen aus YjsDocument übernehmen); trackedOrigins default lassen.
|
||
4. onElementsChanged: via `ydoc.doc.on('update', cb)` oder observe auf die Types (was YjsDocument hergibt); Rückgabe Unsubscribe.
|
||
5. Tests (cadDocument.test.ts, In-Memory-Yjs, kein Netz):
|
||
a. addElement→getAllElements enthält es · b. transact(()=>{add a; add b}) → undo() entfernt BEIDE (ein Schritt!) · c. redo stellt beide wieder her · d. updateElement merged properties shallow · e. deleteElements entfernt nur genannte ids.
|
||
- Verify: `npx vitest run tests/cadDocument.test.ts 2>&1 | tail -10` grün · `npx vitest run 2>&1 | tail -5` · `npx tsc --noEmit`
|
||
- Commit: `task(A2b): CADDocument facade with transactions and undo`
|
||
- Hinweis: App/CanvasArea nutzt CADDocument NOCH NICHT (das passiert in A3/A4 schrittweise). Diese Task ist rein additiv.
|
||
|
||
### Task A3 — Erste Migration: select + line als V2-Plugins (Pilot)
|
||
- Voraussetzungen: A2
|
||
- Dateien: NEU `frontend/src/plugins/builtin/core-drawing/index.ts` (enthält line; select kommt hierher: NEU `core-modify/selectTool.ts` und von core-drawing registriert? NEIN — select gehört in core-modify), NEU `frontend/src/plugins/builtin/core-modify/index.ts`
|
||
- Schritte:
|
||
1. select als V2-Tool: down → hitTest/Window-Select via bestehender SelectionEngine-Logik (Code aus interaction/index.ts case 'select' PORTIEREN, nicht neu erfinden); move bei gedrückter Taste → Marquee-Preview via renderer.setPreview; up → commit selection (docStore.setSelection). Undo: Selektion ist NICHT historisiert (wie bisher).
|
||
2. line als V2-Tool: down setzt Startpunkt; move Preview-Linie; up: `doc.transact(()=>doc.addElement(lineEl))` (eine Transaktion!). Ortho/Snap über bestehende SnapEngine im ctx.
|
||
3. Beide mit `tags:['basic']` (select) bzw. `['basic']` (line).
|
||
4. Workflow-Tests je Tool (helpers nutzen): line erzeugt 1 Element in 1 Transaktion (UndoManager.undo() entfernt es wieder!), select wählt per hit.
|
||
5. Flag an: manuell beide Tools im Browser testen (Zeichnen, Undo, Redo).
|
||
- Verify: suite grün inkl. neuer Tests. Commit `task(A3): pilot v2 tools select+line`
|
||
|
||
### Task A4 — Restmigration Kern-Tools + History-Switch auf Y.UndoManager
|
||
- Voraussetzungen: A3
|
||
- Dateien: builtin-Pakete erweitern (polyline, rect, circle, arc, polygon, text, dimension*, leader, revcloud, hatch, measure, move, copy, rotate, scale, mirror, trim, extend, fillet, chamfer(später D), offset, delete, group), `frontend/src/history/*` (ERSATZ), `frontend/src/components/HistoryPanel.tsx`, `frontend/tests/HistoryManager.test.ts` (umschreiben)
|
||
- Schritte (STRENG sequentiell, je Teilcommit):
|
||
1. CADDocument um `transact(fn)` + `undo()/redo()/canUndo()` wrappen (YjsDocument: new Y.UndoManager([elementsMap, layersMap], {trackedOrigins: 'self'})`). Alte HistoryManager-Klasse PARALLEL lassen bis 4.
|
||
2. Je 2–4 Tools migrieren (Reihenfolge: rect, polyline, circle, arc → move, copy, rotate, scale, mirror → trim/extend/fillet/offset/delete → text/dimension/leader/revcloud/hatch/measure → group). JEDES Mal: Workflowtest mit, Suite grün, Teilcommit `task(A4.x): migrate <tools> to v2`.
|
||
3. Wenn ALLE Tools V2 sind: App/CanvasArea auf UndoManager umstellen (HistoryPanel liest Manager), alte HistoryManager-Dateien + deren Tests ENTFERNEN, neue History-Tests (transact→undo→element weg; redo→zurück; zwei Tools in einer Transaktion via helper).
|
||
4. interaction/index.ts: Rest-Switch löschen. Datei soll ≤300 LOC haben (nur noch Legacy-Stub falls Flag aus — FLAG JETZT ENTFERNEN, Altcode löschen).
|
||
- Verify: `wc -l src/interaction/index.ts` ≤300 · suite grün · Playwright-Smoke falls vorhanden. Commits je Schritt.
|
||
- Nicht tun: neue Tool-Funktionen (Ellipse etc.) — das ist Phase D!
|
||
|
||
## Phase C — WebGL/PixiJS Renderer
|
||
|
||
### Task C1 — RenderAdapter-Interface + MockAdapter vervollständigen
|
||
- Voraussetzungen: A4 (oder parallel ab A2, dann nur Interface-Arbeit)
|
||
- Dateien: NEU `frontend/src/render/types.ts`, ERWEITERN `frontend/tests/helpers/mockAdapter.ts`
|
||
- Interface exakt:
|
||
|
||
```ts
|
||
export interface Viewport { x:number; y:number; scale:number; width:number; height:number; }
|
||
export interface RenderAdapter {
|
||
init(canvas: HTMLCanvasElement): void;
|
||
resize(w:number,h:number,dpr:number): void;
|
||
setViewport(vp: Viewport): void;
|
||
destroy(): void;
|
||
clear(color: string): void;
|
||
drawGrid(cfg: GridCfg): void; drawBackground(img: HTMLImageElement, cfg: BackgroundCfg): void; drawRuler(cfg: RulerCfg): void;
|
||
addOrUpdate(el: CADElement, style: LayerStyle): void; // inkrementell!
|
||
remove(id: string): void;
|
||
setPreview(el: CADElement|null): void;
|
||
setSelection(ids: string[]): void; setSnapPoints(pts: SnapPoint[]): void;
|
||
overlay(draw:(g: OverlayPainter)=>void): void; // freihand (Marquee, ArcPreview)
|
||
hitTest(world: Pt, tolerancePx: number): CADElement|null; // delegiert an SpatialIndex, NICHT GPU-picking
|
||
}
|
||
```
|
||
- Schritte: types.ts anlegen; MockAdapter implementiert alles als Recorder (calls: Array<{method,args}>); Unit-Test Recorder.
|
||
- Verify: suite grün. Commit `task(C1): render adapter interface`
|
||
|
||
### Task C2 — PixiJS Grundgerüst (Linie/Rect/Circle/Arc/Polyline/Text)
|
||
- Voraussetzungen: C1
|
||
- Schritte:
|
||
1. `npm i pixi.js@^8` im frontend (--legacy-peer-deps beachten).
|
||
2. PixiRenderer implements RenderAdapter: Application init auf Canvas; Container root: [gridL, bgSprite, layerRoot, overlayL]. Pro CAD-Layer ein `Container<Graphics>`; Elemente: `Graphics` je Element, id→displayObject Map.
|
||
3. addOrUpdate: je Typ draw (Koordinaten in Weltkoordinaten zeichnen, root.scale/position = viewport → KEINE Neuberechnung pro Element beim Zoom).
|
||
4. Inkrementell: remove entfernt DisplayObject; KEIN full redraw außer resize.
|
||
5. Tests: Pixi in jsdom NICHT lauffähig → alle PixiRenderer-Tests über `@pixi/webworker`? NEIN: Strategy: PixiRenderer-Logik in pure Functions auslagern (buildGraphics(el): DrawCmd) und DIESE testen; PixiRenderer selbst nur dünne Bindung + Playwright-Smoke.
|
||
6. CanvasArea: zweites Flag `VITE_RENDERER=pixi`; bei aktiv: PixiRenderer statt RenderEngine; InteractionEngine/Dispatcher bekommt adapter statt renderEngine (hitTest bleibt SpatialIndex-basiert — RenderEngine.hitTest heute? prüfen und Pfad auf SpatialIndex legen).
|
||
- Verify: build läuft; Playwright smoke `render.pixi.spec.ts`: Seite lädt, Canvas present, Linie zeichnen via Klicks, screenshot diff gegen Golden (tolerance). Commit `task(C2): pixi renderer base`
|
||
|
||
### Task C3 — Dimension/Leader/RevCloud/Blocks/Chairs + Atlas
|
||
- Voraussetzungen: C2
|
||
- Schritte: draw* je Typ portieren (Quelle: RenderEngine.drawDimension u.a. LESEN und 1:1 Geometrie übernehmen). Chairs/Table/Stage: atlas.ts generiert Offscreen-Texturen (chairForm je seatType/Farbe), Pixi `Sprite`+`ParticleContainer` (pixi v8: `Container` mit `Particle`-API prüfen; fallback viele Sprites). Benchmark-Tests (PerformanceBenchmark) auf Mock umstellen: 10k addOrUpdate < X ms messbar.
|
||
- Verify: Playwright: 5000-Chairs-Seite interaktiv; vitest Benchmarks. Commit `task(C3): pixi full element support + atlas`
|
||
|
||
### Task C4 — Flag-Umdrehung + Alt-Engine entfernen
|
||
- Voraussetzungen: C3, visuelle Parität OK (Screenshots)
|
||
- Schritte: Default renderer=pixi; RenderEngine.ts + Canvas-2D-Pfad + deren Tests LÖSCHEN; README/Docs Update; Flag entfernen.
|
||
- Verify: suite grün; Playwright-Suite grün. Commit `task(C4): make pixi the renderer`
|
||
|
||
## Phase D — Werkzeugpalette komplett (alles V2-Plugins)
|
||
Kurz-Tasks (je gleiche Struktur: implementieren im passenden builtin-Paket + Workflowtest + Commit `task(D*)`):
|
||
- [ ] D1 Ellipse+Bogen (core-drawing) — param: cx,cy,rx,ry,rotation; Interaktion: Center→RadiusX→RadiusY (3 Klicks oder Optionsfelder)
|
||
- [ ] D2 Spline (CV-basierte Bézier, Speicherung Kontrollpunkte, Render als interpolierte Polyline mit Glättung)
|
||
- [ ] D3 Point, XLine, Ray (construction-Layer-Tag `properties.construction:true`, Standard-Layer 'defpoints' auto-anlegen)
|
||
- [ ] D4 MTEXT (Mehrzeilig,
|
||
, fontSize/bold/italic Properties; Editor = InlineTextEditor erweitern)
|
||
- [ ] D5 Stretch (Fenster selektiert Endpunkte; verschiebt nur getroffene Vertices)
|
||
- [ ] D6 Break/Join (Break: Element an Punkt splitten; Join: kollineare lines→polyline)
|
||
- [ ] D7 Chamfer, Explode, Align, Lengthen
|
||
- [ ] D8 PolylineEditor (Vertex add/del, segment→arc glätten)
|
||
- [ ] D9 GripEditing (select-Tool erweitern: Handles an Endpunkten/Centern, drag=modify in Transaktion)
|
||
- [ ] D10 Arrays: array-rect (rows,cols,dx,dy), array-polar (cx,count,angleSum,rotate), array-path (entlang polyline/arc) — JEDES als Dialog+Vorschau; Tests mit Zähl-Assertions
|
||
- [ ] D11 Snaps erweitern (SnapEngine + Optionen): tangent, perpendicular, quadrant, center, from-offset (Basispunkt+Eingabefeld dx/dy)
|
||
- [ ] D12 BlockAttribute: BlockDef.attrDefs[], Instanz attrValues; PropertiesPanel rendert Formular; RenderAdapter zeichnet Attr-Texte; (DXF ATTDEF/ATTR erst F)
|
||
|
||
## Phase E — Event-Domain (plugin: event-tools)
|
||
- [ ] E1 seating-row/-block V2 mit Drag-Interaktion + Live-Preview + Optionsleiste (count/spacing/curve)
|
||
- [ ] E2 ArcRows: Radius+Spread+Center(Bühne snap); Stühle rotieren tangential
|
||
- [ ] E3 countSeats in StatusBar (Panel rechts), Klick highlight
|
||
- [ ] E4 Templates: kino, bankett-round, stehtisch, podest, parlamentarisch, u-form (JSON in plugin)
|
||
- [ ] E5 Export Sitzliste CSV/XLSX (xlsx lib oder csv-manuell)
|
||
- [ ] E6 Gäste (optional, 2.1): Backend-Tabelle guests + Zuordnung + CSV-Import
|
||
- [ ] E7 Event-Elemente polish: stage(height attr), curtain, spotlight(angle/color), barrier chain
|
||
|
||
## Phase F — Library & Import/Export
|
||
- [ ] F1 Backend library_folders/library_blocks + Migrationsfile + Tests (CRUD, scopes)
|
||
- [ ] F2 UI LibraryPanel (Baum, Suche, Favoriten, Thumbnail grid), DragDrop→Canvas insert instance
|
||
- [ ] F3 „Als Block speichern“ (Auswahl→Block, Thumbnail client-seitig canvas.toDataURL klein)
|
||
- [ ] F4 LibraryProviderExtension anbinden: builtin-catalog JSONs (event/architecture/landscape Startersets je ~15-30 Blöcke), user-library, global-library
|
||
- [ ] F5 DXF Parser erweitern: ELLIPSE, SPLINE(grad≤3→Polyline approx), MTEXT, POINT, HATCH(basic solid/lines), ATTDEF/ATTR, INSERT→Blockinstanz; Fehlerreport (Liste skipped entities)
|
||
- [ ] F6 DXF Writer erweitern: BLOCKS+INSERTS, ATTR; Version AC1009 (R12) + AC1015 Ziel
|
||
- [ ] F7 .wcadlib Paket (zip: manifest.json, blocks.json, thumbs/) Import+Export (Backend endpoint + UI Dialog)
|
||
- [ ] F8 SVG-Import als Block (svg→Path→Polyline approximation, simple subset: path/rect/circle/ellipse/line/polygon)
|
||
|
||
## Phase G — Layouts & Plot
|
||
- [ ] G1 Datenmodell layouts (Yjs Map: layoutId→{name, viewport{center,scale}, frameBlockRef}), Backend persistence folgt automatisch via drawing json
|
||
- [ ] G2 LayoutBar UI + Viewport-Widget (zeigt Modellbereich skaliert, klickbar zoom-to)
|
||
- [ ] G3 Titelblock-Block mit Attributen (Projekt/Datum/Maßstab/Autor) auto-insert
|
||
- [ ] G4 PDF-Export je Layout im Ausgabemaßstab (pdf-lib; Linienbreiten aus Layern; monochrome Option)
|
||
- [ ] G5 Browser-Print stylesheet (@media print: nur Layout)
|
||
|
||
## Phase H — Modi & Branchenneutralität
|
||
- [ ] H1 simple/pro Mode (uiStore.mode, Ribbon-Filter tags basic, CommandLine hide, Settings persist)
|
||
- [ ] H2 Projekt-Templates (Halle/OpenAir/Saal/Messe/Buero/Garten): JSON Presets (grid unit, layers, enabled plugins, library folders seed)
|
||
- [ ] H3 Rollen: library-admin (global write) vs user (own folders) — an bestehendes auth anbinden, Backend guard
|
||
- [ ] H4 i18n Grundlage: strings.ts zentrale Maps de/en, UI-Texte ersetzen (mechanisch, Teilautomatisierbar)
|
||
- [ ] H5 Flächenberechnung Polygon (m²) Info im PropertiesPanel + measure-area Tool
|
||
|
||
## Phase I — Qualität & Release
|
||
- [ ] I1 CI: forgejo workflow erweitern um performance gate (playwright bench: 10k interaktionsbudget), typecheck, beide Suites
|
||
- [ ] I2 Docs: PLUGIN_GUIDE.md (API v2 + Beispielplugin), LIBRARY_SPEC.md (.wcadlib), CHANGELOG 2.0, README rewrite
|
||
- [ ] I3 Release 2.0 tag + docker images + coolify deploy verify
|
||
|
||
---
|
||
|
||
# TEIL 6 — Offene Entscheidungen (vom Nutzer/Team zu klären, blockieren NICHT außer markiert)
|
||
|
||
| Nr | Entscheidung | Empfehlung | Blockiert |
|
||
|---|---|---|---|
|
||
| Q1 | PixiJS v8 bestätigen | ja | C2 |
|
||
| Q2 | zustand als State-Lib | ja (alternativ jotai) | A2 (sonst eigener Mini-Store) |
|
||
| Q3 | Alte Canvas2D-Engine nach C4 komplett löschen? | ja | C4 |
|
||
| Q4 | Gästemodul E6 in 2.0 oder 2.1 | 2.1 | E6 |
|
||
| Q5 | Fremd-Plugins (ZIP-Install) Freigabe wann | nach M5 | F/A4 Backend-Install |
|
||
|
||
# TEIL 7 — Fortschritts-Log (chronologisch, neueste oben)
|
||
|
||
Format: `YYYY-MM-DD | TASK-ID | was getan | Tests Ergebnis | commit | Notizen/offen`
|
||
|
||
| Datum | Task | Zusammenfassung | Tests | Commit | Notizen |
|
||
|---|---|---|---|---|---|
|
||
| 2026-08-26 | PLAN | ROADMAP.md erstellt, Baseline analysiert | tsc 0, FE 380✓, BE 255✓ | — | Ausgangszustand dokumentiert |
|
||
| 2026-08-26 | B0 | bugs.regress.test.ts angelegt (3 Tests für BUG-1/1b/2); alle 3 ROT wie vorhergesagt; Rest-Suite unverändert grün; Validierung des Dokuments bestanden | FE 380✓ + 3 rot (erwartet), tsc 0 | b9eb69f | Nächster Task: B1 |
|
||
| 2026-08-26 | B1 | nextUid-Helper eingebaut; createSeatingRow rowId vor Schleife; createSeatingBlock blockId via nextUid + rowId pro Reihe in properties | BUG-1+1b GRÜN, 382/383 gesamt (BUG-2 rot wie erwartet), tsc 0 | 1bbd653 | Nächster Task: B2 |
|
||
| 2026-08-26 | B2 | lineCircleIntersections/circleCircleIntersections/lineArcIntersection implementiert; findIntersection auf Typ-Dispatch erweitert; Guards in trim/extend von Truthiness auf undefined korrigiert (Koordinate 0 war falsy); Tangenten-Dedup; 10 neue Unit-Tests | ALLE GRÜN: 393/393 gesamt, tsc 0 | 95b14cf | Nächster Task: B3 |
|
||
| 2026-08-26 | B3 | offsetElement um side-Parameter erweitert (rückwärtskompatibel); Interaktionszweig nutzt Kreuzprodukt (Linie) bzw. Radius-Vergleich (Kreis/Bogen); 4 neue Tests | ALLE GRÜN: 397/397 gesamt, tsc 0 | d8f29e4 | Nächster Task: B4 |
|
||
| 2026-08-26 | B4 | drawBackground cached Bild pro backgroundSrc; kein new Image() pro Frame mehr; Regressionstest mit FakeImage-Zähler | ALLE GRÜN: 398/398 gesamt, tsc 0 | d93ee53 | Nächster Task: B5 |
|
||
| 2026-08-26 | B5 | countSeats um optionales byZone erweitert; Testdatei seating.count.test.ts (5 Tests inkl. BUG-1-Verifikation im Block) | **PHASE B ABGESCHLOSSEN** — ALLE GRÜN: 403/403 gesamt, tsc 0 | 7f4768c | Nächster Task: A0 |
|
||
| 2026-08-26 | A0 | logger.ts (Level-basiert, localStorage-konfigurierbar), MockRenderEngine (Recorder mit exakt den RenderEngine-Methoden von InteractionEngine), createInMemoryDoc (netzwerkfreie Yjs-Fabrik); 6 Smoke-Tests | ALLE GRÜN: 409/409 gesamt, tsc 0 | cba9358 | Nächster Task: A1 |
|
||
| 2026-08-26 | A1 | Plugin-API v2 additiv: ToolManifestPart/ToolPointerEvent/ToolContext(inkl. setPreview?)/ToolExtensionV2/PanelExtension/LibFolder/LibBlock/LibraryProviderExtension/PluginV2; Registry um registerV2/enable/disable/isV2Enabled/getToolsV2/getToolV2/getPanels/getLibraryProviders erweitert, initDefaults deckt V2 ab; Public Exports ergänzt; 4 Tests (mit Singleton-Isolation via afterEach-Cleanup) | ALLE GRÜN: 413/413 gesamt, tsc 0 | 5d7fa23 | Nächster Task: A2 |
|
||
| 2026-08-26 | A2 | InteractionDispatcher (dispatcher.ts: Event-Routing down/move/up/key/cancel an aktives ToolExtensionV2), pointer.ts (Event-Normalisierung screen→world über ZoomPanController.screenToWorld), session.ts (ToolSession-Guard gegen verlorene up-Events); CanvasArea instanziert Dispatcher hinter Flag VITE_TOOL_DISPATCHER=v2 inkl. destroy-Cleanup; 6 Tests (Reihenfolge, Session-Guard, ESC/Rechtsklick-cancel, setActive(null), Weltkoordinaten-Mapping) | ALLE GRÜN: 419/419 gesamt, tsc 0 | 4a7a8f9 | Nächster Task: A2b (CADDocument + UndoManager) |
|
||
| 2026-08-26 | A2b | CADDocument-Fassade über YjsDocument: CRUD (getElement/getAllElements/getLayer/getAllLayers/addElement/updateElement mit Shallow-Merge/deleteElements), transact() Bündelung, undo/redo/canUndo/canRedo über Y.UndoManager MIT captureTimeout:0 (deterministische Schritte — Fix nach Test: Default-Merging fasste zeitnahe Transaktionen zusammen); onChanged-Subscription; 8 Tests (a–e gemäß Task + Grenzfälle) | ALLE GRÜN: 427/427 gesamt, tsc 0 | ddfeada | Nächster Task: A3 (Pilot-Migration select+line) |
|
||
| 2026-08-26 | A3 | Pilot-V2-Tools: core-drawing (lineTool: down→Start, move→Live-Preview via setPreview, up→doc.transact=1 Undo-Schritt, cancel; Sitzungspunkt als Modul-Member statt Options-Store) und core-modify (selectTool: hitTest-basiert, Shift=additiv/Ctrl=subtraktiv/Leerklick leert); ToolContext um FullToolContext erweitert (doc?+selection? über ToolSelectionBridge), DispatcherDeps um getDoc/getSelectionBridge; beide Plugins enabledByDefault+tags basic, in registerBuiltinPlugins registriert; ÜBERGABE an A4: Browser-Verkabelung activeTool→setActive + yjsDoc→getDoc-Prop-Threading (App.tsx); 6 Tests (Line inkl. Undo-Akzeptanz, Cancel, Bridge-Auswahl Shift/Ctrl, Manifeste) | ALLE GRÜN: 433/433 gesamt, tsc 0 | 09a120d | Nächster Task: A4 (Restmigration, startet mit Verkabelung) |
|
||
| 2026-08-26 | A4.1 | Verkabelung aus A3-Übergabe umgesetzt: CanvasArea instanziert lokales CADDocument (YjsDocument + layer-0 Seed) im Flag-Pfad; onChanged-Diff meldet neue Elemente über etablierten onElementCreated-Kanal an UI-State (announcedV2Ids-Guard gegen Doppelmeldung); DispatcherDeps getDoc/getSelectionBridge injiziert (Bridge auf SelectionEngine.getSelectedIds/selectByIds + RenderEngine.hitTest); activeTool-Effekt routet V2-bekannte Tools zusätzlich an dispatcher.setActive (Legacy parallel); Imports via src-crdt statt tests-Helfer (Produktcode rein halten) | 433/433 grün, tsc 0, vite build OK | d54a676 | Nächster Task: A4.2 (Restmigration Block 1: rect) |
|
||
| 2026-08-26 | A4.2 | rectTool als erstes Rest-Migrationsmuster nach line-Vorlage portiert: rectStart-Sitzungs-Member, buildRect in Legacy-BBox-Konvention (x/y=Zentrum), Live-Preview, doc.transact-Commit, cancel; core-drawing v1.1.0 mit tools:[line,rect]; 2 Tests (BBox-Assertions inkl. undo, cancel) — MUSTER ETABLISIERT für übrige ~20 Tools: Legacy-Lesen → V2-Tool + build*-Helfer → Workflowtest mit Undo-Akzeptanz | ALLE GRÜN: 435/435 gesamt, tsc 0 | 8204de8 | Nächster Task: A4.3 (Block circle+arc gleiches Muster) |
|
||
| 2026-08-27 | A4.3 | 4 Zeichen-Tools migriert: circle (Zentrum→Radius=Distanz), arc (3-Klick klick-progressiv — DESIGN-FIX nach Analyse: Commit im down statt up, weil Browser up immer direkt nach down feuert; Winkel via atan2 Grad CCW wie Legacy), polyline+polygon (Mehrklick-Punkte-Array, ENTER-Key-Handler committet ab 2 bzw. 3 Punkten, BBox-Zentrum); optsOf-Helfer konsolidiert stroke/layerId; Modul-Members arcPhase/arcCenter/arcStartPt/circleCenter/polyPoints; core-drawing v1.2.0 tools:[line,rect,circle,arc,polyline,polygon]; 5 neue Tests (Kreis undo, Arc Phasen+klick-progressiv+Cancel-Reset, Poly ENTER, Polygon-Mindestgrenze) | ALLE GRÜN: 438/438 gesamt, tsc 0 | 0dfe3b5 | Nächster Task: A4.4 (annotate: text/mtext) |
|
||
| 2026-08-27 | A4.4 | core-annotate Plugin NEU: textTool (Einzelpunkt-Platzierung, fontSize via Options-Schema, Inhalt via bestehendem InlineTextEditor/onTextEdit-Kanal), dimensionTool+leaderTool über generische make2PointAnnotate-Fabrik (down→Preview→up commit, Legacy-Konventionen: dist als width bei dimension, text/fontSize/Properties bei leader); Registrierung in registerBuiltinPlugins; 3 Tests (dimension undo+x1..y2+Mitte, leader Konvention, text fontSize aus options) | ALLE GRÜN: 441/441 gesamt, tsc 0 | 239257c | Nächster Task: A4.5 (revcloud/hatch/measure) |
|
||
| 2026-08-27 | A4.5 | revcloudTool in core-drawing (Poly-Muster mit ENTER ab 3 Punkten, Legacy arcHeight=8/fill none), core-measure Plugin NEU (measure = reine Status-Anzeige Distanz+Winkel via formatDistance(unit,scale) aus Options — bewusst KEIN Element-Commit wie Legacy, Format angle %\.1f\u00b0), hatchTool in core-modify v1.1.0 (hitTest→doc.updateElement hatch/hatchPattern/hatchSpacing aus Options —.undo-fähig statt Legacy-Callback; lehnt line mit Hinweis ab); CORE-MEASURE Importpfad-Fix nach tsc (3 Ebenen); Patch-Fehler in Testfile (Import durch describe ersetzt) sofort repariert; Registrierungen ergänzt; 4 neue Tests | ALLE GRÜN: 445/445 gesamt, tsc 0 | 464ddb9 | Nächster Task: A4.6 (Modify-Block move/copy/rotate/scale/mirror/delete) |
|
||
|
||
## Gefundene Nebenprobleme (noch nicht zugewiesen)
|
||
- `webhook-receiver.py` im Root: Zweck unklar, ggf. entfernen/dokumentieren (Frage an Nutzer)
|
||
- `phase2..4-task-spec.md` veraltet gegenüber BAUPLAN — nach v2.0 archivieren
|
||
- `frontend/src/utils/__tests__/format.test.ts` liegt in src statt tests/ — vereinheitlichen (kleiner Task in I2)
|
||
|
||
---
|
||
*Nächster offener Task laut Reihenfolge: **A0***
|