@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/annotations-draw-modifiers.test.ts

@@ -1,206 +0,0 @@
-// annotations-layer — draw-time resize modifiers (constrainDrawBox +
-// applyDrawModifiers). FigJam parity: Shift = 1:1, Alt = from-center, applied
-// while CREATING a shape (not just resizing an existing one). Pure functions.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  type ArrowStroke,
-  applyDrawModifiers,
-  constrainDrawBox,
-  type EllipseStroke,
-  type PenStroke,
-  type PolygonStroke,
-  type RectStroke,
-  type StickyStroke,
-} from '../annotations-layer.tsx';
-
-const NONE = { shift: false, alt: false };
-
-describe('constrainDrawBox', () => {
-  test('no modifiers — corner drag from the anchor (back-compat)', () => {
-    expect(constrainDrawBox(10, 20, 110, 70, NONE)).toEqual({ x: 10, y: 20, w: 100, h: 50 });
-  });
-
-  test('Shift — locks to a square via the dominant axis, keeps sign', () => {
-    expect(constrainDrawBox(0, 0, 120, 200, { shift: true, alt: false })).toEqual({
-      x: 0,
-      y: 0,
-      w: 200,
-      h: 200,
-    });
-    expect(constrainDrawBox(0, 0, -120, -200, { shift: true, alt: false })).toEqual({
-      x: 0,
-      y: 0,
-      w: -200,
-      h: -200,
-    });
-  });
-
-  test('Alt — grows from the anchor as center', () => {
-    const b = constrainDrawBox(50, 50, 120, 80, { shift: false, alt: true });
-    expect(b).toEqual({ x: -20, y: 20, w: 140, h: 60 });
-    expect(b.x + b.w / 2).toBe(50); // center invariant
-    expect(b.y + b.h / 2).toBe(50);
-  });
-
-  test('Shift+Alt — centered square', () => {
-    expect(constrainDrawBox(0, 0, 120, 200, { shift: true, alt: true })).toEqual({
-      x: -200,
-      y: -200,
-      w: 400,
-      h: 400,
-    });
-  });
-});
-
-describe('applyDrawModifiers / rect + polygon', () => {
-  const rect: RectStroke = {
-    id: 'r',
-    tool: 'rect',
-    color: '#000',
-    width: 2,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-  };
-  const poly: PolygonStroke = {
-    id: 'p',
-    tool: 'polygon',
-    shape: 'triangle',
-    color: '#000',
-    width: 2,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-  };
-  test('rect no-mod corner drag', () => {
-    expect(applyDrawModifiers(rect, { x: 0, y: 0 }, 100, 50, NONE)).toMatchObject({
-      x: 0,
-      y: 0,
-      w: 100,
-      h: 50,
-    });
-  });
-  test('rect Shift → square', () => {
-    expect(
-      applyDrawModifiers(rect, { x: 0, y: 0 }, 100, 50, { shift: true, alt: false })
-    ).toMatchObject({ w: 100, h: 100 });
-  });
-  test('polygon Alt → centered, preserves shape discriminant', () => {
-    const out = applyDrawModifiers(poly, { x: 50, y: 50 }, 120, 80, {
-      shift: false,
-      alt: true,
-    }) as PolygonStroke;
-    expect(out).toMatchObject({ x: -20, y: 20, w: 140, h: 60, shape: 'triangle' });
-  });
-});
-
-describe('applyDrawModifiers / ellipse', () => {
-  const ell: EllipseStroke = {
-    id: 'e',
-    tool: 'ellipse',
-    color: '#000',
-    width: 2,
-    cx: 0,
-    cy: 0,
-    rx: 0,
-    ry: 0,
-  };
-  test('no-mod — corner drag (bbox 0..100 × 0..50)', () => {
-    expect(applyDrawModifiers(ell, { x: 0, y: 0 }, 100, 50, NONE)).toMatchObject({
-      cx: 50,
-      cy: 25,
-      rx: 50,
-      ry: 25,
-    });
-  });
-  test('Alt — centered on the anchor', () => {
-    expect(
-      applyDrawModifiers(ell, { x: 50, y: 50 }, 120, 80, { shift: false, alt: true })
-    ).toMatchObject({ cx: 50, cy: 50, rx: 70, ry: 30 });
-  });
-  test('Shift — circle (rx === ry)', () => {
-    const out = applyDrawModifiers(ell, { x: 0, y: 0 }, 100, 40, {
-      shift: true,
-      alt: false,
-    }) as EllipseStroke;
-    expect(out.rx).toBe(out.ry);
-  });
-});
-
-describe('applyDrawModifiers / sticky — always square', () => {
-  const sticky: StickyStroke = {
-    id: 's',
-    tool: 'sticky',
-    color: '#fce8a6',
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-    text: '',
-    fontSize: 16,
-  };
-  test('no-mod still square (larger axis)', () => {
-    expect(applyDrawModifiers(sticky, { x: 0, y: 0 }, 150, 120, NONE)).toMatchObject({
-      w: 150,
-      h: 150,
-    });
-  });
-  test('Alt — centered square', () => {
-    expect(
-      applyDrawModifiers(sticky, { x: 0, y: 0 }, 150, 120, { shift: false, alt: true })
-    ).toMatchObject({ x: -150, y: -150, w: 300, h: 300 });
-  });
-});
-
-describe('applyDrawModifiers / arrow', () => {
-  const arrow: ArrowStroke = {
-    id: 'a',
-    tool: 'arrow',
-    color: '#000',
-    width: 2,
-    x1: 0,
-    y1: 0,
-    x2: 0,
-    y2: 0,
-  };
-  test('no-mod — start fixed at anchor, end follows cursor', () => {
-    expect(applyDrawModifiers(arrow, { x: 0, y: 0 }, 100, 40, NONE)).toMatchObject({
-      x1: 0,
-      y1: 0,
-      x2: 100,
-      y2: 40,
-    });
-  });
-  test('Alt — anchor is the midpoint, start mirrors the end', () => {
-    expect(
-      applyDrawModifiers(arrow, { x: 0, y: 0 }, 100, 40, { shift: false, alt: true })
-    ).toMatchObject({ x1: -100, y1: -40, x2: 100, y2: 40 });
-  });
-  test('Shift — end snaps to a 45° shaft', () => {
-    const out = applyDrawModifiers(arrow, { x: 0, y: 0 }, 50, 60, {
-      shift: true,
-      alt: false,
-    }) as ArrowStroke;
-    expect(out.x2).toBeCloseTo(out.y2, 6);
-  });
-});
-
-describe('applyDrawModifiers / pen — pass-through', () => {
-  const pen: PenStroke = {
-    id: 'pen',
-    tool: 'pen',
-    color: '#000',
-    width: 2,
-    points: [
-      [0, 0],
-      [5, 5],
-    ],
-  };
-  test('pen is returned unchanged (no box constraint)', () => {
-    expect(applyDrawModifiers(pen, { x: 0, y: 0 }, 99, 99, { shift: true, alt: true })).toBe(pen);
-  });
-});

package/apps/studio/test/annotations-groups.test.ts

@@ -1,231 +0,0 @@
-// annotations-groups — FigJam v3 grouping / duplicate / z-order (pure, DOM-free).
-// Group model: flat `groupIds` tag-array, deepest→shallowest, outermost = last.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  duplicateStrokes,
-  expandIdsToGroups,
-  groupStrokes,
-  normalizeGroups,
-  outermostGroupOf,
-  reorderStrokes,
-  ungroupStrokes,
-} from '../annotations-groups.ts';
-import type {
-  ArrowStroke,
-  PenStroke,
-  RectStroke,
-  Stroke,
-  TextStroke,
-} from '../annotations-model.ts';
-
-function rect(id: string, x = 0, extra: Partial<RectStroke> = {}): RectStroke {
-  return { id, tool: 'rect', color: '#1f1f1f', width: 3, x, y: 0, w: 100, h: 80, ...extra };
-}
-function pen(id: string, extra: Partial<PenStroke> = {}): PenStroke {
-  return {
-    id,
-    tool: 'pen',
-    color: '#e5484d',
-    width: 3,
-    points: [
-      [0, 0],
-      [10, 10],
-    ],
-    ...extra,
-  };
-}
-function arrow(id: string, extra: Partial<ArrowStroke> = {}): ArrowStroke {
-  return { id, tool: 'arrow', color: '#1f1f1f', width: 3, x1: 0, y1: 0, x2: 50, y2: 0, ...extra };
-}
-
-describe('outermostGroupOf / expandIdsToGroups', () => {
-  test('outermost group is the LAST groupIds element (deepest→shallowest)', () => {
-    expect(outermostGroupOf(rect('a', 0, { groupIds: ['inner', 'outer'] }))).toBe('outer');
-    expect(outermostGroupOf(rect('a'))).toBeNull();
-  });
-
-  test('expanding one member id selects the whole outermost group, in z order', () => {
-    const strokes: Stroke[] = [
-      rect('a', 0, { groupIds: ['g1'] }),
-      pen('loose'),
-      rect('b', 200, { groupIds: ['g1'] }),
-    ];
-    expect(expandIdsToGroups(['b'], strokes)).toEqual(['a', 'b']);
-  });
-
-  test('ungrouped ids pass through; mixed selection keeps both', () => {
-    const strokes: Stroke[] = [
-      rect('a', 0, { groupIds: ['g1'] }),
-      pen('loose'),
-      rect('b', 200, { groupIds: ['g1'] }),
-    ];
-    expect(expandIdsToGroups(['loose', 'a'], strokes)).toEqual(['a', 'loose', 'b']);
-  });
-});
-
-describe('groupStrokes', () => {
-  test('groups ≥2 strokes under a fresh outermost id, contiguous at the topmost member', () => {
-    const strokes: Stroke[] = [rect('a'), pen('mid'), rect('b', 200)];
-    const res = groupStrokes(strokes, ['a', 'b'], 'gNew');
-    expect(res).not.toBeNull();
-    if (!res) return;
-    // Block lands where the topmost member ('b') sat — after 'mid'.
-    expect(res.strokes.map((s) => s.id)).toEqual(['mid', 'a', 'b']);
-    expect(
-      res.strokes.filter((s) => s.id !== 'mid').every((s) => outermostGroupOf(s) === 'gNew')
-    ).toBe(true);
-    expect(res.memberIds).toEqual(['a', 'b']);
-  });
-
-  test('grouping a group with a loose stroke NESTS (old id stays deeper)', () => {
-    const strokes: Stroke[] = [
-      rect('a', 0, { groupIds: ['g1'] }),
-      rect('b', 100, { groupIds: ['g1'] }),
-      pen('c'),
-    ];
-    const res = groupStrokes(strokes, ['c', 'a'], 'g2');
-    expect(res).not.toBeNull();
-    if (!res) return;
-    const a = res.strokes.find((s) => s.id === 'a');
-    expect(a?.groupIds).toEqual(['g1', 'g2']);
-    const c = res.strokes.find((s) => s.id === 'c');
-    expect(c?.groupIds).toEqual(['g2']);
-  });
-
-  test('fewer than two resolved members → null', () => {
-    expect(groupStrokes([rect('a')], ['a'])).toBeNull();
-    expect(groupStrokes([rect('a')], ['a', 'ghost'])).toBeNull();
-  });
-});
-
-describe('ungroupStrokes / normalizeGroups', () => {
-  test('ungroup strips ONE level (the outermost) and drops the key when empty', () => {
-    const strokes: Stroke[] = [
-      rect('a', 0, { groupIds: ['g1', 'g2'] }),
-      rect('b', 100, { groupIds: ['g1', 'g2'] }),
-    ];
-    const out = ungroupStrokes(strokes, ['a']);
-    expect(out.map((s) => s.groupIds)).toEqual([['g1'], ['g1']]);
-    const out2 = ungroupStrokes(out, ['b']);
-    for (const s of out2) expect('groupIds' in s).toBe(false);
-  });
-
-  test('normalizeGroups dissolves singleton groups after a delete', () => {
-    const strokes: Stroke[] = [rect('a', 0, { groupIds: ['g1'] }), pen('loose')];
-    const out = normalizeGroups(strokes);
-    expect('groupIds' in (out[0] as Stroke)).toBe(false);
-    // Referential no-op when nothing changes.
-    const stable: Stroke[] = [rect('x', 0, { groupIds: ['g'] }), rect('y', 1, { groupIds: ['g'] })];
-    expect(normalizeGroups(stable)).toBe(stable);
-  });
-});
-
-describe('duplicateStrokes', () => {
-  test('clones with fresh ids, remapped group ids, offset applied', () => {
-    let n = 0;
-    const makeId = () => `dup${++n}`;
-    const strokes: Stroke[] = [
-      rect('a', 0, { groupIds: ['g1'] }),
-      rect('b', 100, { groupIds: ['g1'] }),
-    ];
-    const res = duplicateStrokes(strokes, ['a'], 16, 16, makeId, () => 'gDup');
-    expect(res.strokes).toHaveLength(4);
-    expect(res.newIds).toEqual(['dup1', 'dup2']);
-    const dup1 = res.strokes.find((s) => s.id === 'dup1') as RectStroke;
-    expect(dup1.x).toBe(16);
-    expect(dup1.groupIds).toEqual(['gDup']);
-    // Originals untouched.
-    expect((res.strokes.find((s) => s.id === 'a') as RectStroke).x).toBe(0);
-  });
-
-  test('anchored text travels with its duplicated host and is NOT selectable', () => {
-    const host = rect('host');
-    const label: TextStroke = {
-      id: 'label',
-      tool: 'text',
-      color: '#1a1a1a',
-      fontSize: 14,
-      text: 'hi',
-      anchorId: 'host',
-    };
-    let n = 0;
-    const res = duplicateStrokes([host, label], ['host'], 10, 0, () => `d${++n}`);
-    expect(res.strokes).toHaveLength(4);
-    const dupLabel = res.strokes.find((s) => s.tool === 'text' && s.id !== 'label') as TextStroke;
-    expect(dupLabel.anchorId).toBe('d1'); // remapped to the cloned host
-    expect(res.newIds).toEqual(['d1']); // anchored-text clone excluded
-  });
-
-  test('arrow binds remap to co-duplicated hosts; binds to outside hosts are kept', () => {
-    const a = rect('a');
-    const b = rect('b', 300);
-    const ar = arrow('ar', {
-      startBind: { hostId: 'a', nx: 1, ny: 0.5 },
-      endBind: { hostId: 'b', nx: 0, ny: 0.5 },
-    });
-    let n = 0;
-    const res = duplicateStrokes([a, b, ar], ['a', 'ar'], 0, 0, () => `d${++n}`);
-    const dupArrow = res.strokes.find((s) => s.tool === 'arrow' && s.id !== 'ar') as ArrowStroke;
-    expect(dupArrow.startBind?.hostId).toBe('d1'); // co-duplicated → remapped
-    expect(dupArrow.endBind?.hostId).toBe('b'); // outside host → kept
-  });
-});
-
-describe('reorderStrokes (z-order, group-contiguous units)', () => {
-  const base = (): Stroke[] => [
-    rect('a'),
-    rect('g1a', 100, { groupIds: ['g1'] }),
-    rect('g1b', 200, { groupIds: ['g1'] }),
-    pen('top'),
-  ];
-
-  test('bring to front / send to back move the unit as one block', () => {
-    expect(reorderStrokes(base(), ['a'], 'front').map((s) => s.id)).toEqual([
-      'g1a',
-      'g1b',
-      'top',
-      'a',
-    ]);
-    expect(reorderStrokes(base(), ['top'], 'back').map((s) => s.id)).toEqual([
-      'top',
-      'a',
-      'g1a',
-      'g1b',
-    ]);
-  });
-
-  test('forward/backward hop over a WHOLE neighbouring group', () => {
-    expect(reorderStrokes(base(), ['a'], 'forward').map((s) => s.id)).toEqual([
-      'g1a',
-      'g1b',
-      'a',
-      'top',
-    ]);
-    expect(reorderStrokes(base(), ['top'], 'backward').map((s) => s.id)).toEqual([
-      'a',
-      'top',
-      'g1a',
-      'g1b',
-    ]);
-  });
-
-  test('selecting one group member moves the whole group', () => {
-    expect(reorderStrokes(base(), ['g1b'], 'front').map((s) => s.id)).toEqual([
-      'a',
-      'top',
-      'g1a',
-      'g1b',
-    ]);
-  });
-
-  test('already at the boundary is a no-op', () => {
-    expect(reorderStrokes(base(), ['top'], 'forward').map((s) => s.id)).toEqual([
-      'a',
-      'g1a',
-      'g1b',
-      'top',
-    ]);
-  });
-});