@1agh/maude 1.0.11 → 1.3.0

package/apps/studio/figma/to-render.test.ts

@@ -1,180 +0,0 @@
-// figma/to-render.ts — the render-first page → canvas path.
-//
-// The rules here are the ones the JSX path got wrong on a real 6-page file, so
-// each test names the observed failure rather than the abstract behaviour.
-
-import { describe, expect, test } from 'bun:test';
-
-import { ImportReport } from './sanitize.ts';
-import { classifyPageChildren, toRenderCanvas } from './to-render.ts';
-import { normalizeDocument } from './types.ts';
-
-const KEY = 'dGNzRC2kmrmGnOxaBa0RI7';
-const box = (x: number, y: number, width: number, height: number) => ({ x, y, width, height });
-
-function pageDoc(children: unknown[]) {
-  const doc = normalizeDocument(
-    { id: '0:0', name: 'Page', type: 'CANVAS', children },
-    { fileKey: KEY, surface: 'design' }
-  );
-  return { doc, page: doc.root };
-}
-
-const frame = (id: string, name = id, extra: Record<string, unknown> = {}) => ({
-  id,
-  name,
-  type: 'FRAME',
-  visible: true,
-  absoluteBoundingBox: box(0, 0, 375, 812),
-  ...extra,
-});
-
-describe('classification (the split-personality bug)', () => {
-  test('a SECTION contributes its frames as artboards AND itself as a region', () => {
-    // Observed: the section landed on the annotation layer while the frames
-    // inside it landed as artboards, so the page read as half-migrated.
-    const { page } = pageDoc([
-      {
-        id: '1:1',
-        name: 'Flow A',
-        type: 'SECTION',
-        visible: true,
-        absoluteBoundingBox: box(0, 0, 1200, 900),
-        children: [frame('1:2', 'Screen 1'), frame('1:3', 'Screen 2')],
-      },
-    ]);
-    const report = new ImportReport();
-    const { frames, annotations } = classifyPageChildren(page, report);
-
-    expect(frames.map((f) => f.id)).toEqual(['1:2', '1:3']);
-    expect(annotations).toHaveLength(1);
-    expect(annotations[0].id).toBe('1:1');
-    // The region travels WITHOUT its contents — they are artboards now.
-    expect(annotations[0].children ?? []).toHaveLength(0);
-  });
-
-  test('FigJam furniture stays on the annotation layer even in a design file', () => {
-    // A flow diagram drawn in CONNECTORs inside a design file is the common case.
-    const { page } = pageDoc([
-      frame('1:2'),
-      {
-        id: '1:9',
-        name: 'note',
-        type: 'STICKY',
-        visible: true,
-        absoluteBoundingBox: box(0, 0, 240, 240),
-      },
-      {
-        id: '1:10',
-        name: 'link',
-        type: 'CONNECTOR',
-        visible: true,
-        absoluteBoundingBox: box(0, 0, 100, 10),
-      },
-    ]);
-    const { frames, annotations } = classifyPageChildren(page, new ImportReport());
-    expect(frames.map((f) => f.id)).toEqual(['1:2']);
-    expect(annotations.map((a) => a.id).sort()).toEqual(['1:10', '1:9']);
-  });
-
-  test('loose page content is never dropped', () => {
-    // Silent content loss is this importer's worst failure mode; a stray text
-    // node has to land SOMEWHERE.
-    const { page } = pageDoc([
-      frame('1:2'),
-      {
-        id: '1:5',
-        name: 'label',
-        type: 'TEXT',
-        visible: true,
-        absoluteBoundingBox: box(9, 9, 80, 20),
-      },
-    ]);
-    const { annotations } = classifyPageChildren(page, new ImportReport());
-    expect(annotations.map((a) => a.id)).toEqual(['1:5']);
-  });
-
-  test('an invisible node contributes nothing at all', () => {
-    const { page } = pageDoc([frame('1:2'), frame('1:3', 'hidden', { visible: false })]);
-    const { frames, annotations } = classifyPageChildren(page, new ImportReport());
-    expect(frames.map((f) => f.id)).toEqual(['1:2']);
-    expect(annotations).toHaveLength(0);
-  });
-});
-
-describe('emission', () => {
-  test('every artboard references a render placeholder, never inlined markup', () => {
-    // The `<img>` reference IS the containment: an SVG in an <img> cannot run
-    // script or fetch a subresource.
-    const { doc, page } = pageDoc([frame('1:2', 'Screen')]);
-    const out = toRenderCanvas(doc, page);
-
-    expect(out.artboardCount).toBe(1);
-    expect(out.pendingRenders).toHaveLength(1);
-    expect(out.pendingRenders[0].node.id).toBe('1:2');
-    expect(out.tsx).toContain('<img');
-    expect(out.tsx).toContain(out.pendingRenders[0].placeholder);
-    expect(out.tsx).not.toContain('<svg');
-  });
-
-  test('artboard positions normalize to the page origin', () => {
-    // A page living at x=12000 in Figma still opens at the canvas origin.
-    const { doc, page } = pageDoc([
-      frame('1:2', 'a', { absoluteBoundingBox: box(12000, 500, 375, 812) }),
-      frame('1:3', 'b', { absoluteBoundingBox: box(12500, 500, 375, 812) }),
-    ]);
-    const out = toRenderCanvas(doc, page);
-    const xs = (out.meta.layout as { artboards: Array<{ x: number }> }).artboards.map((a) => a.x);
-    expect(xs).toEqual([0, 500]);
-    expect(out.origin).toEqual({ x: 12000, y: 500 });
-  });
-
-  test("the frame's own fill backs the render", () => {
-    // Without this a transparent render shows the canvas ground through, which
-    // is how white Figma screens arrived black in a dark-themed project.
-    const { doc, page } = pageDoc([
-      frame('1:2', 'white', {
-        fills: [{ type: 'SOLID', visible: true, color: { r: 1, g: 1, b: 1, a: 1 } }],
-      }),
-    ]);
-    expect(toRenderCanvas(doc, page).tsx).toContain('background="#ffffff"');
-  });
-
-  test('a page with no frames renders whole rather than importing empty', () => {
-    // Regression: a scratch page of loose content produced ZERO artboards, so
-    // the canvas opened blank and the page looked like it had not imported.
-    const { doc, page } = pageDoc([
-      {
-        id: '1:5',
-        name: 'note',
-        type: 'TEXT',
-        visible: true,
-        absoluteBoundingBox: box(10, 20, 80, 20),
-      },
-      {
-        id: '1:6',
-        name: 'box',
-        type: 'RECTANGLE',
-        visible: true,
-        absoluteBoundingBox: box(30, 40, 100, 60),
-      },
-    ]);
-    const out = toRenderCanvas(doc, page);
-
-    expect(out.artboardCount).toBe(1);
-    // Figma renders a CANVAS node, so the page's own id is the render target.
-    expect(out.pendingRenders[0].node.id).toBe('0:0');
-    // Its content is inside that render — emitting it again would double it.
-    expect(out.annotations).toHaveLength(0);
-  });
-
-  test('meta keeps every frame node id so one artboard can be exploded later', () => {
-    const { doc, page } = pageDoc([frame('1:2', 'Screen'), frame('1:3', 'Other')]);
-    const meta = toRenderCanvas(doc, page).meta as {
-      mode: string;
-      figma: { frames: Array<{ nodeId: string }> };
-    };
-    expect(meta.mode).toBe('render');
-    expect(meta.figma.frames.map((f) => f.nodeId)).toEqual(['1:2', '1:3']);
-  });
-});

package/apps/studio/figma/to-strokes-roundtrip.test.ts

@@ -1,152 +0,0 @@
-// The DISK round-trip for an imported FigJam board: strokes → SVG → sanitize →
-// re-parse. The parse side needs a DOMParser, which bun:test does not expose,
-// so happy-dom is registered for THIS FILE ONLY (beforeAll/afterAll) — the same
-// split `annotations-layer.test.ts` / `annotations-roundtrip.test.ts` already
-// uses, so the rest of the suite keeps running DOM-free.
-//
-// Two properties are load-bearing and neither is covered by the DOM-free tests:
-//
-//  1. **The emitted file passes `sanitizeAnnotationSvg` without losing
-//     content.** DDR-216 D6's annotation row requires the sanitizer to run
-//     before write. If this translator ever emitted something outside the
-//     element allowlist, the sanitizer would silently strip it and the import
-//     would lose strokes with no error anywhere.
-//  2. **Connector binds survive to disk and back.** "Always editable" (the
-//     governing principle) is only true if an imported arrow is still a LIVE,
-//     re-routable bind after a save/load cycle — not a frozen line.
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-import type { ArrowStroke, Stroke } from '../annotations-model.ts';
-import { sanitizeAnnotationSvg, strokesToSvg, svgToStrokes } from '../annotations-model.ts';
-import { toStrokes } from './to-strokes.ts';
-import { normalizeDocument } from './types.ts';
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-});
-
-afterAll(async () => {
-  await GlobalRegistrator.unregister();
-});
-
-const box = (x: number, y: number, width: number, height: number) => ({ x, y, width, height });
-
-/** A small board carrying one of each round-trip-relevant shape. */
-function board() {
-  return {
-    id: '0:0',
-    name: 'Document',
-    type: 'CANVAS',
-    children: [
-      {
-        id: '1:2',
-        name: 'Sekce vnější',
-        type: 'SECTION',
-        absoluteBoundingBox: box(-500, -500, 1200, 900),
-      },
-      {
-        id: '1:8',
-        name: 'Sticky',
-        type: 'STICKY',
-        absoluteBoundingBox: box(-400, -400, 240, 240),
-        characters: 'Persona A',
-      },
-      {
-        id: '2:17',
-        name: 'Příliš žluťoučký — "test" / <b> & \'x\'',
-        type: 'SHAPE_WITH_TEXT',
-        shapeType: 'SQUARE',
-        absoluteBoundingBox: box(0, 0, 200, 200),
-        characters: 'Čtverec',
-      },
-      {
-        id: '2:21',
-        name: 'Ellipse',
-        type: 'SHAPE_WITH_TEXT',
-        shapeType: 'ELLIPSE',
-        absoluteBoundingBox: box(300, 0, 200, 200),
-      },
-      {
-        id: '2:50',
-        name: 'Archetyp',
-        type: 'TEXT',
-        absoluteBoundingBox: box(0, 300, 120, 30),
-        characters: 'Archetyp',
-        style: { fontSize: 16 },
-      },
-      {
-        id: '2:67',
-        name: 'C1',
-        type: 'CONNECTOR',
-        absoluteBoundingBox: box(200, 100, 100, 10),
-        connectorStart: { endpointNodeId: '2:17' },
-        connectorEnd: { endpointNodeId: '2:21' },
-        connectorEndCap: 'ARROW_LINES',
-      },
-      {
-        id: '2:71',
-        name: 'C2 → TEXT (the widening case)',
-        type: 'CONNECTOR',
-        absoluteBoundingBox: box(100, 250, 100, 10),
-        connectorStart: { endpointNodeId: '2:21' },
-        connectorEnd: { endpointNodeId: '2:50' },
-        connectorEndCap: 'ARROW_LINES',
-      },
-    ],
-  };
-}
-
-function translated() {
-  const doc = normalizeDocument(board(), { fileKey: 'Em6NOwaOFTYV7NlQT4NK8l', surface: 'board' });
-  return toStrokes(doc, { resetIds: true });
-}
-
-const kinds = (list: readonly Stroke[]) => list.map((s) => s.tool).sort();
-
-describe('imported board → SVG → sanitize → re-parse', () => {
-  test('the sanitizer loses nothing — every stroke survives', () => {
-    const { strokes } = translated();
-    const reparsed = svgToStrokes(sanitizeAnnotationSvg(strokesToSvg(strokes)));
-    expect(reparsed.length).toBe(strokes.length);
-    expect(kinds(reparsed)).toEqual(kinds(strokes));
-  });
-
-  test('connector binds survive — the arrow stays LIVE, not frozen', () => {
-    const { strokes } = translated();
-    const reparsed = svgToStrokes(sanitizeAnnotationSvg(strokesToSvg(strokes)));
-    const boundOf = (list: readonly Stroke[]) =>
-      (list.filter((s) => s.tool === 'arrow') as ArrowStroke[]).filter(
-        (a) => a.startBind || a.endBind
-      ).length;
-    expect(boundOf(strokes)).toBeGreaterThan(0);
-    expect(boundOf(reparsed)).toBe(boundOf(strokes));
-  });
-
-  test('the bind onto a TEXT host survives the round-trip (DDR-216 D9)', () => {
-    const { strokes } = translated();
-    const textStroke = strokes.find((s) => s.tool === 'text' && s.text === 'Archetyp');
-    const reparsed = svgToStrokes(sanitizeAnnotationSvg(strokesToSvg(strokes)));
-    const stillBound = (reparsed.filter((s) => s.tool === 'arrow') as ArrowStroke[]).some(
-      (a) => a.endBind?.hostId === textStroke?.id || a.startBind?.hostId === textStroke?.id
-    );
-    expect(stillBound).toBe(true);
-  });
-
-  test('the hostile layer name never survives as markup', () => {
-    const { strokes } = translated();
-    const sanitized = sanitizeAnnotationSvg(strokesToSvg(strokes));
-    expect(sanitized).not.toContain('<b>');
-    expect(sanitized).not.toContain('<script');
-    // …and no event handler or style attribute ever appears.
-    expect(sanitized).not.toMatch(/\son[a-z]+=/i);
-  });
-
-  test('sticky geometry survives the round-trip un-normalised', () => {
-    const { strokes } = translated();
-    const reparsed = svgToStrokes(sanitizeAnnotationSvg(strokesToSvg(strokes)));
-    const sticky = reparsed.find((s) => s.tool === 'sticky') as { w: number; h: number };
-    expect([sticky.w, sticky.h]).toEqual([240, 240]);
-  });
-});