Agent Zero
223 lines
9.2 KiB
TypeScript
223 lines
9.2 KiB
TypeScript
/**
|
||
* Task CAD-4 – OTRACK + DIVIDE/MEASURE.
|
||
*
|
||
* OTRACK: Tracking-Vektoren von Fang-Punkten (horizontal/vertikal/
|
||
* Winkelmultiples), SnapEngine-Erweiterung.
|
||
* DIVIDE: n gleichmaeßige Punkte auf einem Pfad.
|
||
* MEASURE: Punkte im festen Abstand auf einem Pfad.
|
||
*/
|
||
import { describe, it, expect, beforeEach } from 'vitest';
|
||
import { SnapEngine, computeTrackPoint } from '../src/canvas/SnapEngine';
|
||
import { divideTool, measureTool, pointsAlongPath } from '../src/plugins/builtin/core-modify';
|
||
import { CADDocument } from '../src/kernel/document/CADDocument';
|
||
import { createInMemoryDoc } from './helpers/inMemoryDoc';
|
||
import type { CADElement, Pt } from '../src/types/cad.types';
|
||
|
||
function mkCtx(elements: CADElement[], options: Record<string, unknown> = {}) {
|
||
const { ydoc } = createInMemoryDoc();
|
||
const doc = new CADDocument(ydoc);
|
||
for (const el of elements) doc.addElement(el);
|
||
const selectedIds = new Set<string>();
|
||
const statuses: string[] = [];
|
||
const ctx: any = {
|
||
doc,
|
||
options,
|
||
setStatus: (m: string) => statuses.push(m),
|
||
setPreview: (_el: CADElement | null) => {},
|
||
selection: {
|
||
getIds: () => Array.from(selectedIds),
|
||
setIds: (ids: string[]) => {
|
||
selectedIds.clear();
|
||
for (const id of ids) selectedIds.add(id);
|
||
},
|
||
hitTest: (x: number, y: number, _tol: number) => {
|
||
for (const el of elements) {
|
||
const p = el.properties as Record<string, unknown>;
|
||
if (Array.isArray(p.points)) {
|
||
const pts = p.points as Pt[];
|
||
for (let i = 0; i < pts.length - 1; i++) {
|
||
const dx = pts[i + 1].x - pts[i].x;
|
||
const dy = pts[i + 1].y - pts[i].y;
|
||
const len = Math.hypot(dx, dy) || 1;
|
||
const t = Math.max(0, Math.min(1, ((x - pts[i].x) * dx + (y - pts[i].y) * dy) / (len * len)));
|
||
const px = pts[i].x + t * dx;
|
||
const py = pts[i].y + t * dy;
|
||
if (Math.hypot(x - px, y - py) < 10) return el;
|
||
}
|
||
}
|
||
if (
|
||
x >= el.x - el.width / 2 - 5 && x <= el.x + el.width / 2 + 5 &&
|
||
y >= el.y - el.height / 2 - 5 && y <= el.y + el.height / 2 + 5
|
||
) return el;
|
||
}
|
||
return null;
|
||
},
|
||
},
|
||
};
|
||
return { ctx, doc, selectedIds, statuses };
|
||
}
|
||
|
||
function pe(x: number, y: number, mods: { shift?: boolean } = {}): { world: Pt; shift: boolean; ctrl: boolean } {
|
||
return { world: { x, y }, shift: mods.shift ?? false, ctrl: false } as never;
|
||
}
|
||
|
||
function path(pts: Array<[number, number]>): CADElement {
|
||
return {
|
||
id: 'path-1', type: 'polyline', layerId: 'l',
|
||
x: pts.reduce((s, p) => s + p[0], 0) / pts.length,
|
||
y: pts.reduce((s, p) => s + p[1], 0) / pts.length,
|
||
width: Math.max(...pts.map(p => p[0])) - Math.min(...pts.map(p => p[0])),
|
||
height: Math.max(...pts.map(p => p[1])) - Math.min(...pts.map(p => p[1])),
|
||
properties: { points: pts.map(([x, y]) => ({ x, y })) },
|
||
} as unknown as CADElement;
|
||
}
|
||
|
||
beforeEach(() => {
|
||
divideTool.handlers.cancel?.({ setStatus: () => {}, setPreview: () => {} } as never);
|
||
measureTool.handlers.cancel?.({ setStatus: () => {}, setPreview: () => {} } as never);
|
||
});
|
||
|
||
// ─── OTRACK: computeTrackPoint ────────────────────────────────
|
||
|
||
describe('CAD-4: computeTrackPoint (OTRACK)', () => {
|
||
it('horizontal von Basis (100,100) bei Cursor (200,90): Track-Punkt (200,100)', () => {
|
||
const result = computeTrackPoint({ x: 100, y: 100 }, { x: 200, y: 90 });
|
||
expect(result).not.toBeNull();
|
||
expect(result!.x).toBeCloseTo(200, 6);
|
||
expect(result!.y).toBeCloseTo(100, 6);
|
||
});
|
||
|
||
it('vertikal von Basis (100,100) bei Cursor (90,200): Track-Punkt (100,200)', () => {
|
||
const result = computeTrackPoint({ x: 100, y: 100 }, { x: 90, y: 200 });
|
||
expect(result).not.toBeNull();
|
||
expect(result!.x).toBeCloseTo(100, 6);
|
||
expect(result!.y).toBeCloseTo(200, 6);
|
||
});
|
||
|
||
it('45-Grad-Richtung wird verfolgt', () => {
|
||
// Basis (0,0), Cursor (100,80): 45 Grad heißt y=x → Track (100,100)
|
||
const result = computeTrackPoint({ x: 0, y: 0 }, { x: 100, y: 80 }, [0, 45, 90, 135, 180, 225, 270, 315]);
|
||
expect(result).not.toBeNull();
|
||
expect(result!.x).toBeCloseTo(100, 6);
|
||
expect(result!.y).toBeCloseTo(100, 6);
|
||
});
|
||
|
||
it('Cursor genau auf der Basis: kein Track (null)', () => {
|
||
expect(computeTrackPoint({ x: 100, y: 100 }, { x: 100, y: 100 })).toBeNull();
|
||
});
|
||
|
||
it('ohne Winkel-Option: nur 0/90/180/270 (Standard-Tracking)', () => {
|
||
// 30-Grad-Cursor nahe horizontal: snappt auf horizontal
|
||
const result = computeTrackPoint({ x: 0, y: 0 }, { x: 100, y: 15 });
|
||
expect(result).not.toBeNull();
|
||
expect(result!.x).toBeCloseTo(100, 6);
|
||
expect(result!.y).toBeCloseTo(0, 6);
|
||
});
|
||
});
|
||
|
||
// ─── pointsAlongPath (reine Funktion) ─────────────────────────
|
||
|
||
describe('CAD-4: pointsAlongPath', () => {
|
||
it('DIVIDE: 4 Segmente auf 100-Einheiten-Pfad → 5 Punkte (inkl. Enden)', () => {
|
||
const pts = [{ x: 0, y: 0 }, { x: 100, y: 0 }];
|
||
const result = pointsAlongPath(pts, 4);
|
||
expect(result).toHaveLength(5);
|
||
expect(result[0]).toEqual({ x: 0, y: 0 });
|
||
expect(result[2]).toEqual({ x: 50, y: 0 });
|
||
expect(result[4]).toEqual({ x: 100, y: 0 });
|
||
});
|
||
|
||
it('MEASURE: Abstand 25 auf 100-Einheiten-Pfad → 5 Punkte', () => {
|
||
const pts = [{ x: 0, y: 0 }, { x: 100, y: 0 }];
|
||
const result = pointsAlongPath(pts, 0, 25);
|
||
expect(result).toHaveLength(5);
|
||
expect(result[3]).toEqual({ x: 75, y: 0 });
|
||
});
|
||
|
||
it('MEASURE mit Rest: 30 auf 100 → 4 Punkte (Rest 10 verworfen)', () => {
|
||
const pts = [{ x: 0, y: 0 }, { x: 100, y: 0 }];
|
||
const result = pointsAlongPath(pts, 0, 30);
|
||
expect(result).toHaveLength(4);
|
||
expect(result[3]).toEqual({ x: 90, y: 0 });
|
||
});
|
||
|
||
it('gebogener L-Pfad: Punkte folgen der Geometrie', () => {
|
||
const pts = [{ x: 0, y: 0 }, { x: 50, y: 0 }, { x: 50, y: 50 }];
|
||
const result = pointsAlongPath(pts, 3); // 3 Segmente auf 100 Gesamtlänge → 4 Punkte
|
||
expect(result).toHaveLength(4);
|
||
expect(result[0]).toEqual({ x: 0, y: 0 });
|
||
expect(result[2].x).toBeCloseTo(50, 0);
|
||
expect(result[3]).toEqual({ x: 50, y: 50 });
|
||
});
|
||
});
|
||
|
||
// ─── divideTool ────────────────────────────────────────────
|
||
|
||
describe('CAD-4: divideTool', () => {
|
||
it('Klick auf Pfad + count=4 platziert 5 Punkte', () => {
|
||
const p = path([[0, 0], [100, 0]]);
|
||
const { ctx, doc } = mkCtx([p], { count: 4 });
|
||
divideTool.handlers.down!(pe(50, 0), ctx);
|
||
const points = doc.getAllElements().filter((e) => e.type === 'circle' && e.properties.point);
|
||
expect(points).toHaveLength(5);
|
||
});
|
||
|
||
it('Punkte liegen auf defpoints-Layer mit construction:true', () => {
|
||
const p = path([[0, 0], [100, 0]]);
|
||
const { ctx, doc } = mkCtx([p], { count: 2 });
|
||
divideTool.handlers.down!(pe(50, 0), ctx);
|
||
const points = doc.getAllElements().filter((e) => e.properties.construction);
|
||
expect(points.length).toBeGreaterThanOrEqual(3);
|
||
expect(points.every((e) => e.layerId === 'defpoints')).toBe(true);
|
||
});
|
||
|
||
it('Klick ohne Pfad-Treffer: kein Element, Status erklaert', () => {
|
||
const { ctx, doc, statuses } = mkCtx([], { count: 2 });
|
||
divideTool.handlers.down!(pe(500, 500), ctx);
|
||
expect(doc.getAllElements()).toHaveLength(0);
|
||
expect(statuses[statuses.length - 1]).toContain('Polyline');
|
||
});
|
||
|
||
it('ALLES in EINER Transaktion (1 Undo entfernt alle Punkte)', () => {
|
||
const p = path([[0, 0], [100, 0]]);
|
||
const { ctx, doc } = mkCtx([p], { count: 4 });
|
||
divideTool.handlers.down!(pe(50, 0), ctx);
|
||
expect(doc.getAllElements().length).toBeGreaterThan(1);
|
||
doc.undo();
|
||
expect(doc.getAllElements()).toHaveLength(1); // Nur der Pfad bleibt
|
||
});
|
||
});
|
||
|
||
// ─── measureTool ────────────────────────────────────────────
|
||
|
||
describe('CAD-4: measureTool', () => {
|
||
it('Klick auf Pfad + Abstand 25 platziert 5 Punkte', () => {
|
||
const p = path([[0, 0], [100, 0]]);
|
||
const { ctx, doc } = mkCtx([p], { spacing: 25 });
|
||
measureTool.handlers.down!(pe(50, 0), ctx);
|
||
const points = doc.getAllElements().filter((e) => e.type === 'circle' && e.properties.point);
|
||
expect(points).toHaveLength(5);
|
||
});
|
||
|
||
it('count=0 (keine Segmente) mit spacing nutzt Abstand', () => {
|
||
const p = path([[0, 0], [100, 0]]);
|
||
const { ctx, doc } = mkCtx([p], { spacing: 20 });
|
||
measureTool.handlers.down!(pe(50, 0), ctx);
|
||
const points = doc.getAllElements().filter((e) => e.type === 'circle' && e.properties.point);
|
||
expect(points).toHaveLength(6); // 0, 20, 40, 60, 80, 100
|
||
});
|
||
});
|
||
|
||
// ─── Manifeste ──────────────────────────────────────────────
|
||
|
||
describe('CAD-4: Manifeste', () => {
|
||
it('ids und Optionen korrekt', () => {
|
||
expect(divideTool.manifest.id).toBe('divide');
|
||
expect(measureTool.manifest.id).toBe('measure');
|
||
const divKeys = (divideTool.optionsSchema ?? []).map((f) => f.key);
|
||
expect(divKeys).toContain('count');
|
||
const meaKeys = (measureTool.optionsSchema ?? []).map((f) => f.key);
|
||
expect(meaKeys).toContain('spacing');
|
||
});
|
||
});
|