@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/sizing-mode.test.ts

@@ -1,102 +0,0 @@
-// sizing-mode.ts — Stage M1 (feature-element-editing-robustness). The pure
-// Fixed / Hug / Fill mode classification + the deterministic CSS patch it writes,
-// including the context-aware Fill (flex main axis → flex-grow, cross axis →
-// align-self, block/grid → 100%).
-
-import { describe, expect, test } from 'bun:test';
-
-import { isMainAxis, sizingModeOf, sizingModePatch } from '../sizing-mode.ts';
-
-const flexRow = { display: 'flex', flexDirection: 'row' };
-const flexCol = { display: 'flex', flexDirection: 'column' };
-const block = { display: 'block' };
-
-describe('sizing-mode / isMainAxis', () => {
-  test('row parent → width is main, height is cross', () => {
-    expect(isMainAxis('width', flexRow)).toBe(true);
-    expect(isMainAxis('height', flexRow)).toBe(false);
-  });
-  test('column parent → height is main, width is cross', () => {
-    expect(isMainAxis('height', flexCol)).toBe(true);
-    expect(isMainAxis('width', flexCol)).toBe(false);
-  });
-  test('missing direction defaults to row', () => {
-    expect(isMainAxis('width', { display: 'flex' })).toBe(true);
-  });
-});
-
-describe('sizing-mode / sizingModeOf', () => {
-  test('numeric authored value → fixed', () => {
-    expect(sizingModeOf('width', { width: '200px' })).toBe('fixed');
-  });
-  test('fit-content → hug', () => {
-    expect(sizingModeOf('width', { width: 'fit-content' })).toBe('hug');
-  });
-  test('100% → fill', () => {
-    expect(sizingModeOf('width', { width: '100%' })).toBe('fill');
-  });
-  test('flex-grow ≥ 1 on the main axis → fill', () => {
-    expect(sizingModeOf('width', { 'flex-grow': '1' }, {}, flexRow)).toBe('fill');
-  });
-  test('flex-grow on the cross axis is NOT fill (grow is a main-axis property)', () => {
-    expect(sizingModeOf('height', { 'flex-grow': '1' }, {}, flexRow)).toBe('fixed');
-  });
-  test('align-self stretch on the cross axis → fill', () => {
-    expect(sizingModeOf('height', { 'align-self': 'stretch' }, {}, flexRow)).toBe('fill');
-  });
-  test('nothing authored → fixed default', () => {
-    expect(sizingModeOf('width', {}, { width: '640px' })).toBe('fixed');
-  });
-});
-
-describe('sizing-mode / sizingModePatch', () => {
-  test('fixed writes an explicit px from the current rendered size', () => {
-    const p = sizingModePatch('width', 'fixed', block, 321.6);
-    expect(p.set).toEqual([['width', '322px']]);
-    expect(p.reset).toEqual([]);
-  });
-
-  test('hug writes fit-content', () => {
-    const p = sizingModePatch('height', 'hug', block, 100);
-    expect(p.set).toEqual([['height', 'fit-content']]);
-  });
-
-  test('fill on a block child writes 100%', () => {
-    const p = sizingModePatch('width', 'fill', block, 100);
-    expect(p.set).toEqual([['width', '100%']]);
-  });
-
-  test('fill on a flex MAIN axis uses flex-grow + basis, releases the dimension', () => {
-    const p = sizingModePatch('width', 'fill', flexRow, 100);
-    expect(p.set).toEqual([
-      ['flex-grow', '1'],
-      ['flex-basis', '0%'],
-      ['width', 'auto'],
-    ]);
-  });
-
-  test('fill on a flex CROSS axis uses align-self: stretch', () => {
-    const p = sizingModePatch('height', 'fill', flexRow, 100);
-    expect(p.set).toEqual([
-      ['align-self', 'stretch'],
-      ['height', 'auto'],
-    ]);
-  });
-
-  test('switching a flex-main child back to fixed clears the fill props', () => {
-    const p = sizingModePatch('width', 'fixed', flexRow, 240);
-    expect(p.set).toEqual([['width', '240px']]);
-    expect(p.reset).toEqual(['flex-grow', 'flex-basis']);
-  });
-
-  test('switching a flex-cross child to hug clears align-self', () => {
-    const p = sizingModePatch('height', 'hug', flexRow, 240);
-    expect(p.set).toEqual([['height', 'fit-content']]);
-    expect(p.reset).toEqual(['align-self']);
-  });
-
-  test('non-positive / non-finite currentPx clamps to 0px for fixed', () => {
-    expect(sizingModePatch('width', 'fixed', block, 0).set).toEqual([['width', '0px']]);
-    expect(sizingModePatch('width', 'fixed', block, Number.NaN).set).toEqual([['width', '0px']]);
-  });
-});

package/apps/studio/test/slash-commands.test.ts

@@ -1,117 +0,0 @@
-// Unit tests for the pure command model behind the ACP composer autocomplete +
-// inline pill (client/panels/slash-commands.js). No DOM — importable directly.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  buildCommandModel,
-  filterCommands,
-  groupOf,
-  matchLeadingCommand,
-  normalizeName,
-  STATIC_COMMANDS,
-} from '../client/panels/slash-commands.js';
-
-describe('normalizeName', () => {
-  test('strips a leading slash, lowercases, trims', () => {
-    expect(normalizeName('/design:Edit')).toBe('design:edit');
-    expect(normalizeName('  FLOW:Plan  ')).toBe('flow:plan');
-    expect(normalizeName('design:edit')).toBe('design:edit');
-  });
-  test('is empty-safe', () => {
-    expect(normalizeName('')).toBe('');
-    expect(normalizeName(null as unknown as string)).toBe('');
-    expect(normalizeName(undefined as unknown as string)).toBe('');
-  });
-});
-
-describe('groupOf', () => {
-  test('extracts the plugin prefix', () => {
-    expect(groupOf('design:edit')).toBe('design');
-    expect(groupOf('flow:bug-fix')).toBe('flow');
-    expect(groupOf('bare')).toBe('other');
-  });
-});
-
-describe('matchLeadingCommand', () => {
-  test('typing mode: leading slash token with no space', () => {
-    expect(matchLeadingCommand('/')).toEqual({ token: '', full: null, typing: true });
-    expect(matchLeadingCommand('/desi')).toEqual({ token: 'desi', full: null, typing: true });
-    expect(matchLeadingCommand('/design:edit')).toEqual({
-      token: 'design:edit',
-      full: null,
-      typing: true,
-    });
-    // Leading whitespace is tolerated (trimmed).
-    expect(matchLeadingCommand('  /design')).toEqual({
-      token: 'design',
-      full: null,
-      typing: true,
-    });
-  });
-  test('highlight mode: command followed by a space', () => {
-    expect(matchLeadingCommand('/design:edit make it bolder')).toEqual({
-      token: 'design:edit',
-      full: '/design:edit',
-      typing: false,
-    });
-    expect(matchLeadingCommand('/flow:quick ')).toEqual({
-      token: 'flow:quick',
-      full: '/flow:quick',
-      typing: false,
-    });
-  });
-  test('non-command text returns null', () => {
-    expect(matchLeadingCommand('make the button bigger')).toBeNull();
-    expect(matchLeadingCommand('email me at a/b')).toBeNull(); // mid-string slash is not a command
-    expect(matchLeadingCommand('')).toBeNull();
-  });
-});
-
-describe('buildCommandModel', () => {
-  test('cold (no live list) → static keys are the optimistic exists-set', () => {
-    const { all, existsSet } = buildCommandModel(STATIC_COMMANDS, []);
-    expect(all.length).toBe(STATIC_COMMANDS.length);
-    expect(existsSet.has('design:edit')).toBe(true);
-    expect(existsSet.has('design:new')).toBe(true);
-    // every static command is present + flagged not-live
-    expect(all.every((c) => c.live === false)).toBe(true);
-  });
-
-  test('warm (live list) → live names are the strict authority, and demote unknowns', () => {
-    const live = [
-      { name: 'design:edit', description: 'live desc' },
-      { name: '/design:new', description: '' }, // slash + separator variance tolerated
-      { name: 'user:custom', description: 'a user command' },
-    ];
-    const { all, existsSet } = buildCommandModel(STATIC_COMMANDS, live);
-    // exists-set is strictly the live set
-    expect(existsSet.has('design:edit')).toBe(true);
-    expect(existsSet.has('design:new')).toBe(true);
-    expect(existsSet.has('user:custom')).toBe(true);
-    // a shipped static command NOT in the live set is no longer "exists"
-    expect(existsSet.has('design:critic')).toBe(false);
-    // live-only command is added to the union
-    expect(all.find((c) => c.name === 'user:custom')?.live).toBe(true);
-    // static command present in live is marked live
-    expect(all.find((c) => c.name === 'design:edit')?.live).toBe(true);
-  });
-});
-
-describe('filterCommands', () => {
-  test('empty token returns the capped list', () => {
-    const { all } = buildCommandModel(STATIC_COMMANDS, []);
-    expect(filterCommands(all, '', 5).length).toBe(5);
-  });
-  test('prefix matches rank before substring matches', () => {
-    const { all } = buildCommandModel(STATIC_COMMANDS, []);
-    const res = filterCommands(all, 'design:', 20);
-    expect(res.length).toBeGreaterThan(0);
-    expect(res.every((c) => c.name.startsWith('design:'))).toBe(true);
-  });
-  test('matches on description substring too', () => {
-    const { all } = buildCommandModel(STATIC_COMMANDS, []);
-    const res = filterCommands(all, 'critic', 20);
-    expect(res.some((c) => c.name === 'design:critic')).toBe(true);
-  });
-});

package/apps/studio/test/snap-distance-pill.test.ts

@@ -1,68 +0,0 @@
-// snap-distance-pill — DDR-046. Verifies SnapGuide.delta + .kind population
-// in `computeSnap`. The visual `Δ{Math.round(delta)}` pill rendering lives in
-// `SnapGuideOverlay` (`canvas-lib.tsx`); this file covers only the pure-function
-// contract that the overlay reads.
-
-import { describe, expect, test } from 'bun:test';
-
-import { computeSnap, type Rect, type SnapOptions } from '../use-snap-guides.tsx';
-
-const DEFAULTS: SnapOptions = { gridSize: 40, tolerance: 8, disabled: false };
-const rect = (x: number, y: number, w = 100, h = 80): Rect => ({ x, y, w, h });
-
-describe('SnapGuide.delta + .kind (DDR-046)', () => {
-  test('grid snap emits delta + kind=grid', () => {
-    const r = computeSnap(rect(33, 200), [], DEFAULTS);
-    const xg = r.guides.find((g) => g.axis === 'x');
-    expect(xg?.delta).toBe(7); // 40 − 33
-    expect(xg?.kind).toBe('grid');
-  });
-
-  test('grid snap with zero delta (already on grid line) still emits kind=grid', () => {
-    const r = computeSnap(rect(40, 200), [], DEFAULTS);
-    const xg = r.guides.find((g) => g.axis === 'x');
-    expect(xg?.delta).toBe(0);
-    expect(xg?.kind).toBe('grid');
-  });
-
-  test('sibling snap beats grid when both fire (closest |delta| wins)', () => {
-    // proposed x=37: grid candidate at 40 (delta +3), sibling at 35 (delta −2).
-    // |−2| < |3| → sibling wins.
-    const r = computeSnap(rect(37, 200), [rect(35, 0, 50, 50)], DEFAULTS);
-    const xg = r.guides.find((g) => g.axis === 'x');
-    expect(xg?.kind).toBe('sibling');
-    expect(xg?.delta).toBe(-2);
-    expect(r.x).toBe(35);
-  });
-
-  test('sibling snap emits delta + kind=sibling', () => {
-    // proposed x=503, sibling at x=500. Snap left↔left.
-    const r = computeSnap(rect(503, 200), [rect(500, 50, 100, 80)], DEFAULTS);
-    const xg = r.guides.find((g) => g.axis === 'x');
-    expect(xg?.delta).toBe(-3);
-    expect(xg?.kind).toBe('sibling');
-    expect(r.x).toBe(500);
-  });
-
-  test('merged-at-pos guide keeps the larger |delta|', () => {
-    // Two siblings both at x=500 — same edge, different y so merged guide
-    // unions their from/to. Both candidates have identical delta here, but
-    // we still expect the merge code path to preserve a single delta value.
-    const r = computeSnap(
-      rect(503, 200),
-      [rect(500, 50, 100, 50), rect(500, 400, 100, 50)],
-      DEFAULTS
-    );
-    const xg = r.guides.find((g) => g.axis === 'x');
-    expect(xg?.delta).toBe(-3);
-    expect(xg?.kind).toBe('sibling');
-    // Merged span covers both siblings' Y extents.
-    expect(xg?.from).toBe(50);
-    expect(xg?.to).toBe(450);
-  });
-
-  test('disabled mode emits no guides (delta + kind absent)', () => {
-    const r = computeSnap(rect(33, 200), [rect(35, 0)], { ...DEFAULTS, disabled: true });
-    expect(r.guides).toEqual([]);
-  });
-});

package/apps/studio/test/spacing-handles.test.ts

@@ -1,138 +0,0 @@
-// spacing-handles.ts — Stage J (feature-element-editing-robustness). Pure
-// geometry for the on-canvas padding + gap drag overlay: padding-edge handle
-// placement + drag math, and flex gap-midpoint placement + drag math.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  computeGapDrag,
-  computeGapMidpoints,
-  computePaddingDrag,
-  computePaddingLines,
-  flexMainAxis,
-  paddingSideSet,
-} from '../spacing-handles.ts';
-
-const RECT = { x: 100, y: 200, w: 300, h: 150 };
-
-describe('spacing-handles / computePaddingLines', () => {
-  test('places all 4 edges at the padding/content boundary, zoom 1', () => {
-    const lines = computePaddingLines(RECT, { top: 10, right: 20, bottom: 30, left: 40 }, 1);
-    const bySide = Object.fromEntries(lines.map((l) => [l.side, l]));
-    expect(bySide.top).toEqual({ side: 'top', axis: 'y', x: 250, y: 210, length: 240 }); // w-40-20
-    expect(bySide.bottom).toEqual({ side: 'bottom', axis: 'y', x: 250, y: 320, length: 240 });
-    expect(bySide.left).toEqual({ side: 'left', axis: 'x', x: 140, y: 275, length: 110 }); // h-10-30
-    expect(bySide.right).toEqual({ side: 'right', axis: 'x', x: 380, y: 275, length: 110 });
-  });
-
-  test('scales the inset by zoom', () => {
-    const lines = computePaddingLines(RECT, { top: 10, right: 0, bottom: 0, left: 0 }, 2);
-    const top = lines.find((l) => l.side === 'top');
-    expect(top?.y).toBe(220); // rect.y + 10*2
-  });
-
-  test('a non-positive zoom falls back to 1x', () => {
-    const lines = computePaddingLines(RECT, { top: 10, right: 0, bottom: 0, left: 0 }, 0);
-    expect(lines.find((l) => l.side === 'top')?.y).toBe(210);
-  });
-});
-
-describe('spacing-handles / computePaddingDrag', () => {
-  test('top grows when dragged DOWN (positive dy)', () => {
-    expect(computePaddingDrag('top', 10, 0, 6, 1)).toBe(16);
-  });
-  test('top shrinks when dragged UP (negative dy)', () => {
-    expect(computePaddingDrag('top', 10, 0, -4, 1)).toBe(6);
-  });
-  test('left grows when dragged RIGHT (positive dx)', () => {
-    expect(computePaddingDrag('left', 8, 5, 0, 1)).toBe(13);
-  });
-  test('bottom grows when dragged UP (sign flips vs top)', () => {
-    expect(computePaddingDrag('bottom', 10, 0, -6, 1)).toBe(16);
-  });
-  test('right grows when dragged LEFT (sign flips vs left)', () => {
-    expect(computePaddingDrag('right', 8, -5, 0, 1)).toBe(13);
-  });
-  test('clamps at 0 — never goes negative', () => {
-    expect(computePaddingDrag('top', 4, 0, -100, 1)).toBe(0);
-  });
-  test('divides the screen delta by zoom (world units)', () => {
-    expect(computePaddingDrag('top', 10, 0, 20, 2)).toBe(20); // 20/2 = +10
-  });
-});
-
-describe('spacing-handles / flexMainAxis', () => {
-  test('row / row-reverse → x', () => {
-    expect(flexMainAxis('row')).toBe('x');
-    expect(flexMainAxis('row-reverse')).toBe('x');
-  });
-  test('column / column-reverse → y', () => {
-    expect(flexMainAxis('column')).toBe('y');
-    expect(flexMainAxis('column-reverse')).toBe('y');
-  });
-  test('missing/empty defaults to row → x', () => {
-    expect(flexMainAxis(null)).toBe('x');
-    expect(flexMainAxis('')).toBe('x');
-  });
-});
-
-describe('spacing-handles / computeGapMidpoints', () => {
-  test('no gaps for < 2 children', () => {
-    expect(computeGapMidpoints([], 'x')).toEqual([]);
-    expect(computeGapMidpoints([RECT], 'x')).toEqual([]);
-  });
-
-  test('one midpoint between 2 children on the X axis, sorted by position', () => {
-    const a = { x: 0, y: 0, w: 100, h: 50 };
-    const b = { x: 120, y: 0, w: 100, h: 50 };
-    // Pass out of order — must sort by x before pairing.
-    expect(computeGapMidpoints([b, a], 'x')).toEqual([{ x: 110, y: 25 }]);
-  });
-
-  test('N-1 midpoints for N children, Y axis (column)', () => {
-    const a = { x: 0, y: 0, w: 80, h: 40 };
-    const b = { x: 0, y: 60, w: 80, h: 40 };
-    const c = { x: 0, y: 120, w: 80, h: 40 };
-    expect(computeGapMidpoints([a, b, c], 'y')).toEqual([
-      { x: 40, y: 50 },
-      { x: 40, y: 110 },
-    ]);
-  });
-});
-
-describe('spacing-handles / paddingSideSet', () => {
-  test('plain drag touches only the dragged side', () => {
-    expect(paddingSideSet('top', false, false)).toEqual(['top']);
-    expect(paddingSideSet('left', false, false)).toEqual(['left']);
-  });
-  test('Alt on top/bottom locks the vertical pair', () => {
-    expect(paddingSideSet('top', true, false)).toEqual(['top', 'bottom']);
-    expect(paddingSideSet('bottom', true, false)).toEqual(['top', 'bottom']);
-  });
-  test('Alt on left/right locks the horizontal pair', () => {
-    expect(paddingSideSet('left', true, false)).toEqual(['left', 'right']);
-    expect(paddingSideSet('right', true, false)).toEqual(['left', 'right']);
-  });
-  test('Alt+Shift locks all 4 sides regardless of which was grabbed', () => {
-    expect(paddingSideSet('top', true, true)).toEqual(['top', 'right', 'bottom', 'left']);
-    expect(paddingSideSet('right', true, true)).toEqual(['top', 'right', 'bottom', 'left']);
-  });
-  test('Shift alone (no Alt) is plain — matches the panel (shift is a step modifier there)', () => {
-    expect(paddingSideSet('top', false, true)).toEqual(['top']);
-  });
-});
-
-describe('spacing-handles / computeGapDrag', () => {
-  test('1:1 with cursor delta on the X axis (no doubling)', () => {
-    expect(computeGapDrag('x', 12, 8, 0, 1)).toBe(20);
-  });
-  test('1:1 with cursor delta on the Y axis', () => {
-    expect(computeGapDrag('y', 12, 0, -8, 1)).toBe(4);
-  });
-  test('clamps at 0', () => {
-    expect(computeGapDrag('x', 4, -100, 0, 1)).toBe(0);
-  });
-  test('divides by zoom', () => {
-    expect(computeGapDrag('x', 10, 20, 0, 2)).toBe(20); // 20/2 = +10
-  });
-});

package/apps/studio/test/specimen-select.test.ts

@@ -1,88 +0,0 @@
-// specimen-select — feature-element-editing-robustness Stage E (Task E1 + G2).
-// A DS preview specimen (`system/<ds>/preview/*.tsx`) has no CanvasShell — no
-// `.dc-canvas` host, no artboard-scoped selector. `isBareSpecimen`/
-// `pickSpecimenSelectEl` (canvas-comment-mount.tsx) are the generalized select
-// resolver that lets a specimen element still resolve to a `Selection` the
-// Inspector can edit, with a NULL artboard scope (the selector degrades to a
-// bare `[data-cd-id="…"]`, per dom-selection.ts `scopedCdSelector`).
-//
-// Needs a live DOM (elementFromPoint / closest / querySelector) — register
-// happy-dom for this file only, same convention as canvas-hmr-runtime.test.tsx.
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-});
-afterAll(() => {
-  GlobalRegistrator.unregister();
-});
-
-import { isBareSpecimen, pickSpecimenSelectEl } from '../canvas-comment-mount.tsx';
-import { hoverTargetToSelection } from '../dom-selection.ts';
-import type { HoverTarget } from '../input-router.tsx';
-
-describe('isBareSpecimen', () => {
-  test('true when no .dc-canvas host is mounted (a bare specimen)', () => {
-    document.body.innerHTML = '<article data-cd-id="aaaaaaaa"><span>hi</span></article>';
-    expect(isBareSpecimen()).toBe(true);
-  });
-
-  test('false when a .dc-canvas host is present (a UI canvas owns select instead)', () => {
-    document.body.innerHTML =
-      '<div class="dc-canvas"><article data-cd-id="aaaaaaaa">hi</article></div>';
-    expect(isBareSpecimen()).toBe(false);
-  });
-});
-
-describe('pickSpecimenSelectEl', () => {
-  test('climbs from the raw hit to its closest stamped [data-cd-id] ancestor', () => {
-    document.body.innerHTML = '<article data-cd-id="aaaaaaaa"><span id="inner">hi</span></article>';
-    const inner = document.getElementById('inner') as HTMLElement;
-    const article = document.querySelector('[data-cd-id]') as HTMLElement;
-    document.elementFromPoint = () => inner;
-
-    const el = pickSpecimenSelectEl(10, 10);
-    expect(el).toBe(article);
-  });
-
-  test('falls back to the bare hit when nothing is stamped (defensive, no crash)', () => {
-    document.body.innerHTML = '<div id="plain">no cd-id here</div>';
-    const plain = document.getElementById('plain') as HTMLElement;
-    document.elementFromPoint = () => plain;
-
-    expect(pickSpecimenSelectEl(5, 5)).toBe(plain);
-  });
-
-  test('returns null over comment chrome / the resize-handle overlay', () => {
-    document.body.innerHTML =
-      '<article data-cd-id="aaaaaaaa"><div class="cm-composer"><span id="chrome">x</span></div></article>';
-    const chromeEl = document.getElementById('chrome') as HTMLElement;
-    document.elementFromPoint = () => chromeEl;
-
-    expect(pickSpecimenSelectEl(1, 1)).toBeNull();
-  });
-
-  test('returns null when the hit is HTML/BODY (no content under the cursor)', () => {
-    document.elementFromPoint = () => document.body;
-    expect(pickSpecimenSelectEl(0, 0)).toBeNull();
-  });
-});
-
-describe('specimen select → Selection has a NULL artboard scope', () => {
-  test('hoverTargetToSelection({artboardId: null}) degrades to a bare [data-cd-id] selector', () => {
-    document.body.innerHTML = '<article data-cd-id="aaaaaaaa">hi</article>';
-    const el = document.querySelector('[data-cd-id]') as HTMLElement;
-    const target: HoverTarget = { el, cdId: 'aaaaaaaa', artboardId: null };
-
-    const sel = hoverTargetToSelection(target);
-
-    expect(sel.artboardId).toBeNull();
-    expect(sel.id).toBe('aaaaaaaa');
-    // No `[data-dc-screen="…"]` artboard scope prefix — a specimen has no
-    // artboard, so the selector must stay bare (dom-selection.ts scopedCdSelector).
-    expect(sel.selector).not.toContain('data-dc-screen');
-    expect(sel.selector).toContain('data-cd-id="aaaaaaaa"');
-  });
-});