@1agh/maude 1.0.9 → 1.2.0

package/apps/studio/test/marquee-overlay.test.ts

@@ -1,94 +0,0 @@
-// marquee-overlay — T26 (Wave 3). Aseprite-vocabulary modifier semantics
-// table tests + applyMarqueeMode set-algebra tests. Pure functions, no DOM.
-
-import { describe, expect, test } from 'bun:test';
-
-import { applyMarqueeMode, modeOf } from '../marquee-overlay.tsx';
-import type { Selection } from '../use-selection-set.tsx';
-
-describe('marquee-overlay / modeOf', () => {
-  test('no modifiers → replace', () => {
-    expect(modeOf({ shiftKey: false, altKey: false })).toBe('replace');
-  });
-  test('shift → add', () => {
-    expect(modeOf({ shiftKey: true, altKey: false })).toBe('add');
-  });
-  test('alt → subtract', () => {
-    expect(modeOf({ shiftKey: false, altKey: true })).toBe('subtract');
-  });
-  test('shift+alt → intersect', () => {
-    expect(modeOf({ shiftKey: true, altKey: true })).toBe('intersect');
-  });
-});
-
-describe('marquee-overlay / applyMarqueeMode', () => {
-  // Stub `selSet` that records the last call so the test can assert outcome.
-  type Recorded = { method: 'replace' | 'add'; payload: Selection[] };
-  const makeStub = () => {
-    const log: Recorded[] = [];
-    const stub = {
-      replace: (s: Selection | Selection[]) => {
-        log.push({ method: 'replace', payload: Array.isArray(s) ? s : [s] });
-      },
-      add: (s: Selection | Selection[]) => {
-        log.push({ method: 'add', payload: Array.isArray(s) ? s : [s] });
-      },
-    };
-    return { stub, log };
-  };
-
-  const sel = (id: string): Selection => ({ id, selector: `[data-cd-id="${id}"]` });
-
-  test('replace with empty hits → no-op (selection preserved)', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(stub, 'replace', [sel('a')], []);
-    expect(log).toHaveLength(0);
-  });
-
-  test('replace with hits → swaps to hits', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(stub, 'replace', [sel('a')], [sel('b'), sel('c')]);
-    expect(log).toEqual([{ method: 'replace', payload: [sel('b'), sel('c')] }]);
-  });
-
-  test('add with empty hits → no-op', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(stub, 'add', [sel('a')], []);
-    expect(log).toHaveLength(0);
-  });
-
-  test('add with hits → adds to existing', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(stub, 'add', [sel('a')], [sel('b')]);
-    expect(log).toEqual([{ method: 'add', payload: [sel('b')] }]);
-  });
-
-  test('subtract removes the hit ids from startSet', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(stub, 'subtract', [sel('a'), sel('b'), sel('c')], [sel('b')]);
-    expect(log).toEqual([{ method: 'replace', payload: [sel('a'), sel('c')] }]);
-  });
-
-  test('subtract with no overlap → identity (replace with startSet)', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(stub, 'subtract', [sel('a'), sel('b')], [sel('z')]);
-    expect(log).toEqual([{ method: 'replace', payload: [sel('a'), sel('b')] }]);
-  });
-
-  test('intersect keeps only ids present in both sets', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(
-      stub,
-      'intersect',
-      [sel('a'), sel('b'), sel('c')],
-      [sel('b'), sel('c'), sel('d')]
-    );
-    expect(log).toEqual([{ method: 'replace', payload: [sel('b'), sel('c')] }]);
-  });
-
-  test('intersect with empty hits → clears (empty replace)', () => {
-    const { stub, log } = makeStub();
-    applyMarqueeMode(stub, 'intersect', [sel('a'), sel('b')], []);
-    expect(log).toEqual([{ method: 'replace', payload: [] }]);
-  });
-});

package/apps/studio/test/media-commit-chain.test.ts

@@ -1,210 +0,0 @@
-// media-commit-chain — the Phase-23 batch-drop no-loss guarantee, isolated
-// from React/DOM/real image decode timing so the race is testable
-// deterministically (no real timers — every "completion" is a microtask-tick
-// count, so the interleaving is exact and reproducible on every run).
-
-import { describe, expect, test } from 'bun:test';
-
-import { createMediaCommitChain } from '../media-commit-chain.ts';
-
-interface Item {
-  id: string;
-}
-
-const keyOf = (it: Item) => it.id;
-
-/** Resolve after exactly `n` microtask ticks (0 = next tick). */
-function afterTicks(n: number): Promise<void> {
-  let p: Promise<void> = Promise.resolve();
-  for (let i = 0; i < n; i++) p = p.then(() => undefined);
-  return p;
-}
-
-describe('media-commit-chain / no-loss under concurrent completions', () => {
-  test('a synchronous burst of N enqueues (worst case — zero timing gap) keeps all N', async () => {
-    let snapshot: Item[] = [];
-    const chain = createMediaCommitChain<Item>(() => snapshot, keyOf);
-    const committed: Item[][] = [];
-    const onCommit = (_before: readonly Item[], after: readonly Item[]) => {
-      committed.push(after as Item[]);
-      snapshot = after as Item[];
-    };
-
-    // All 8 fire back-to-back in the same synchronous tick — the exact shape
-    // of use-canvas-media-drop's batch-dispatch loop calling onImage/onMedia
-    // once per file, each kicking off its own independent async chain that
-    // (in the old, buggy code) raced on a shared strokesRef.current read.
-    const promises = Array.from({ length: 8 }, (_, i) =>
-      chain.enqueue(
-        (before) => ({ after: [...before, { id: `item-${i}` }], label: `add ${i}` }),
-        onCommit
-      )
-    );
-    await Promise.all(promises);
-
-    const final = committed[committed.length - 1];
-    expect(final.length).toBe(8);
-    expect(new Set(final.map((it) => it.id)).size).toBe(8);
-    for (let i = 0; i < 8; i++) {
-      expect(final.some((it) => it.id === `item-${i}`)).toBe(true);
-    }
-  });
-
-  test('staggered/shuffled resolution order still accumulates every item exactly once', async () => {
-    let snapshot: Item[] = [];
-    const chain = createMediaCommitChain<Item>(() => snapshot, keyOf);
-    const committed: Item[][] = [];
-    const onCommit = (_before: readonly Item[], after: readonly Item[]) => {
-      committed.push(after as Item[]);
-      snapshot = after as Item[];
-    };
-
-    // A fixed (non-random, so non-flaky) permutation of tick-depths — some
-    // items resolve in the same tick as others, some land in between,
-    // deliberately out of index order (index 4 resolves before index 0).
-    const tickCounts = [4, 0, 6, 2, 7, 1, 5, 3];
-    const promises = tickCounts.map((ticks, i) =>
-      afterTicks(ticks).then(() =>
-        chain.enqueue(
-          (before) => ({ after: [...before, { id: `item-${i}` }], label: `add ${i}` }),
-          onCommit
-        )
-      )
-    );
-    await Promise.all(promises);
-
-    const final = committed[committed.length - 1];
-    expect(final.length).toBe(8);
-    expect(new Set(final.map((it) => it.id)).size).toBe(8);
-  });
-
-  test('skip (mutate returns null) leaves the accumulator untouched', async () => {
-    let snapshot: Item[] = [];
-    const chain = createMediaCommitChain<Item>(() => snapshot, keyOf);
-    const committed: Item[][] = [];
-    const onCommit = (_before: readonly Item[], after: readonly Item[]) => {
-      committed.push(after as Item[]);
-      snapshot = after as Item[];
-    };
-
-    await chain.enqueue((before) => ({ after: [...before, { id: 'a' }] }), onCommit);
-    const skipped = await chain.enqueue(() => null, onCommit);
-    expect(skipped.map((it) => it.id)).toEqual(['a']);
-    expect(committed.length).toBe(1); // the skipped mutation never called onCommit
-  });
-
-  test('a lagging snapshot (render has not caught up yet) does not lose the prior commit', async () => {
-    // This is the regression caught live against a real dev server (Task 5):
-    // getSnapshot() (strokesRef.current in production) only catches up on
-    // React's NEXT render, which can take longer than the handful of
-    // microtask ticks this chain itself needs to settle a link and go idle.
-    // `rendered` here deliberately never updates on its own — it models a
-    // render that hasn't happened yet by the time the second file's upload
-    // resolves and enqueues.
-    const rendered: Item[] = [];
-    const chain = createMediaCommitChain<Item>(() => rendered, keyOf);
-    const commits: Array<{ after: readonly Item[] }> = [];
-    const onCommit = (_before: readonly Item[], after: readonly Item[]) => {
-      commits.push({ after });
-    };
-
-    await chain.enqueue((before) => ({ after: [...before, { id: 'video' }] }), onCommit);
-    // The chain is idle now (its one link has settled) — `rendered` is still
-    // [] (no render happened). The next enqueue must reconcile against what
-    // THIS chain last produced, not trust the stale empty snapshot.
-    const after = await chain.enqueue(
-      (before) => ({ after: [...before, { id: 'audio' }] }),
-      onCommit
-    );
-
-    expect(after.map((it) => it.id).sort()).toEqual(['audio', 'video']);
-  });
-
-  test('external edits made while idle (snapshot ahead of remembered) are preserved', async () => {
-    let snapshot: Item[] = [{ id: 'external' }];
-    const chain = createMediaCommitChain<Item>(() => snapshot, keyOf);
-    const commits: Array<{ before: readonly Item[]; after: readonly Item[] }> = [];
-    const onCommit = (before: readonly Item[], after: readonly Item[]) => {
-      commits.push({ before, after });
-    };
-
-    await chain.enqueue((before) => ({ after: [...before, { id: 'a' }] }), onCommit);
-    // Simulate a synchronous, non-chained edit that landed while idle (e.g. a
-    // pen stroke committed directly, its render already caught up) — the
-    // next chain link must see it via the fresh snapshot.
-    snapshot = [...snapshot, { id: 'a' }, { id: 'pen-stroke' }];
-    await chain.enqueue((before) => ({ after: [...before, { id: 'b' }] }), onCommit);
-
-    const last = commits[commits.length - 1];
-    expect(last.after.some((it) => it.id === 'pen-stroke')).toBe(true);
-    expect(last.after.some((it) => it.id === 'b')).toBe(true);
-  });
-
-  test('a snapshot with a STALE VALUE for a chain-owned id (not just a missing one) does not revert it', async () => {
-    // The real bug this closes: `fresh` (getSnapshot) can contain the SAME
-    // id the chain just committed, but with a stale value — e.g. an image
-    // stroke's optimistic (blob:) href is set via a separate, non-chain
-    // setState, and `fresh` catches up to THAT before it catches up to the
-    // chain's own later commit swapping it to the real href. Checking only
-    // "is the id present" (the previous implementation) treated this as
-    // "already rendered, trust fresh" and used the stale copy — silently
-    // reverting the swap, which then gets filtered out entirely as
-    // still-ephemeral at the persistence layer one level up. Confirmed live
-    // against a real dev server: a single 3-file drop lost exactly one file
-    // most of the time, always the one whose swap commit landed while
-    // `fresh` still only reflected its pre-swap optimistic value.
-    const snapshot: Item[] = [{ id: 'img-optimistic', href: 'blob:x' } as unknown as Item];
-    const chain = createMediaCommitChain<Item>(() => snapshot, keyOf);
-    const commits: Array<{ after: readonly Item[] }> = [];
-    const onCommit = (_before: readonly Item[], after: readonly Item[]) => {
-      commits.push({ after });
-    };
-
-    // The chain's own commit swaps the id to its real value...
-    await chain.enqueue(
-      (before) => ({
-        after: before.map((it) =>
-          it.id === 'img-optimistic' ? { ...it, href: 'assets/real.png' } : it
-        ),
-      }),
-      onCommit
-    );
-    // ...but `snapshot` (fresh) hasn't re-rendered to reflect that swap yet
-    // — it still shows the SAME id with the stale, optimistic href. This
-    // models the render lag, not a delete/re-add.
-
-    const after = await chain.enqueue(
-      (before) => ({ after: [...before, { id: 'sibling' }] }),
-      onCommit
-    );
-
-    const img = after.find((it) => it.id === 'img-optimistic') as unknown as { href: string };
-    expect(img?.href).toBe('assets/real.png');
-    expect(after.some((it) => it.id === 'sibling')).toBe(true);
-  });
-
-  test('commitBefore overrides the before passed to onCommit without affecting the accumulator', async () => {
-    const snapshot: Item[] = [{ id: 'optimistic' }];
-    const chain = createMediaCommitChain<Item>(() => snapshot, keyOf);
-    const commits: Array<{ before: readonly Item[]; after: readonly Item[] }> = [];
-    const onCommit = (before: readonly Item[], after: readonly Item[]) => {
-      commits.push({ before, after });
-    };
-
-    // Mirrors createImageFromFile's swap: "before" (accumulator) still
-    // contains the ephemeral optimistic entry, but the undo record's
-    // `before` should exclude it (undo removes the image outright instead
-    // of restoring a revoked blob: URL).
-    const after = await chain.enqueue(
-      (before) => ({
-        after: before.map((it) => (it.id === 'optimistic' ? { id: 'real' } : it)),
-        commitBefore: before.filter((it) => it.id !== 'optimistic'),
-      }),
-      onCommit
-    );
-
-    expect(after).toEqual([{ id: 'real' }]);
-    expect(commits[0].before).toEqual([]);
-    expect(commits[0].after).toEqual([{ id: 'real' }]);
-  });
-});

package/apps/studio/test/mode-toggle.test.tsx

@@ -1,226 +0,0 @@
-// mode-toggle — DDR-223 (issue #93). The preview/edit mode layer over the
-// DDR-187 browse/move tool split: boot posture, the mode⇄tool invariant
-// (arming a resting tool moves the mode; annotation tools are mode-neutral),
-// resetTool, read-only preview boot, and the palette's segmented toggle.
-//
-// Needs a live DOM (context callbacks fired via act) — register happy-dom +
-// drive a createRoot, same convention as browse-posture.test.tsx.
-
-import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test';
-import { GlobalRegistrator } from '@happy-dom/global-registrator';
-
-beforeAll(() => {
-  GlobalRegistrator.register();
-  (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
-});
-afterAll(() => {
-  GlobalRegistrator.unregister();
-});
-
-import { act, type ReactNode } from 'react';
-import { createRoot, type Root } from 'react-dom/client';
-import type { Tool } from '../input-router.tsx';
-import { _resetReadOnlyCache } from '../read-only-mode.ts';
-import { ToolPalette } from '../tool-palette.tsx';
-import { type CanvasMode, ToolProvider, useToolMode } from '../use-tool-mode.tsx';
-
-// Capture the live context value so tests can drive setMode/setTool/resetTool
-// directly and assert the resulting (tool, mode) pair.
-let ctx: ReturnType<typeof useToolMode> | null = null;
-function Capture() {
-  ctx = useToolMode();
-  return null;
-}
-
-let root: Root | null = null;
-let host: HTMLElement | null = null;
-
-function mount(ui: ReactNode): void {
-  host = document.createElement('div');
-  document.body.appendChild(host);
-  root = createRoot(host);
-  act(() => {
-    root?.render(ui);
-  });
-}
-
-afterEach(() => {
-  act(() => {
-    root?.unmount();
-  });
-  host?.remove();
-  root = null;
-  host = null;
-  ctx = null;
-  _resetReadOnlyCache();
-  setPageUrl('http://localhost/');
-});
-
-// happy-dom: `history.replaceState` does not update `location.search`; the
-// DetachedWindowAPI `setURL` is the supported seam.
-function setPageUrl(url: string): void {
-  (window as unknown as { happyDOM?: { setURL?: (u: string) => void } }).happyDOM?.setURL?.(url);
-}
-
-const pair = (): { tool: Tool; mode: CanvasMode } => ({
-  tool: ctx?.tool as Tool,
-  mode: ctx?.mode as CanvasMode,
-});
-
-describe('mode-toggle / boot posture (DDR-223)', () => {
-  test('default boot = edit with move armed', () => {
-    mount(
-      <ToolProvider>
-        <Capture />
-      </ToolProvider>
-    );
-    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
-  });
-
-  test('initial="browse" boots preview (comment-mount specimen posture)', () => {
-    mount(
-      <ToolProvider initial="browse">
-        <Capture />
-      </ToolProvider>
-    );
-    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
-  });
-
-  test('read-only (?ro=1) boots preview/browse — the DDR-187 viewer posture', () => {
-    setPageUrl('http://localhost/?ro=1');
-    _resetReadOnlyCache();
-    mount(
-      <ToolProvider>
-        <Capture />
-      </ToolProvider>
-    );
-    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
-  });
-});
-
-describe('mode-toggle / mode⇄tool invariant', () => {
-  test('setMode arms the resting tool both ways', () => {
-    mount(
-      <ToolProvider>
-        <Capture />
-      </ToolProvider>
-    );
-    act(() => ctx?.setMode('preview'));
-    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
-    act(() => ctx?.setMode('edit'));
-    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
-  });
-
-  test('arming a resting tool moves the mode (V / tool-set / escape hatch)', () => {
-    mount(
-      <ToolProvider>
-        <Capture />
-      </ToolProvider>
-    );
-    act(() => ctx?.setTool('browse'));
-    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
-    // The Cmd+click-in-browse escape hatch is a plain setTool('move') at its
-    // call site — the invariant is what turns it into a coherent mode flip.
-    act(() => ctx?.setTool('move'));
-    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
-  });
-
-  test('annotation tools are mode-neutral — pen in preview stays preview', () => {
-    mount(
-      <ToolProvider initial="browse">
-        <Capture />
-      </ToolProvider>
-    );
-    act(() => ctx?.setTool('pen'));
-    expect(pair()).toEqual({ tool: 'pen', mode: 'preview' });
-    act(() => ctx?.setTool('comment'));
-    expect(pair()).toEqual({ tool: 'comment', mode: 'preview' });
-  });
-
-  test('resetTool arms the CURRENT mode’s resting tool', () => {
-    mount(
-      <ToolProvider initial="browse">
-        <Capture />
-      </ToolProvider>
-    );
-    // Preview: drawing an annotation then resetting returns to browse (the
-    // alive posture) — never to move.
-    act(() => ctx?.setTool('pen'));
-    act(() => ctx?.resetTool());
-    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
-    // Edit: byte-identical to the pre-DDR-223 hardcoded setTool('move').
-    act(() => ctx?.setMode('edit'));
-    act(() => ctx?.setTool('pen'));
-    act(() => ctx?.resetTool());
-    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
-  });
-});
-
-describe('mode-toggle / palette segmented toggle', () => {
-  const mountPalette = () =>
-    mount(
-      <ToolProvider>
-        <Capture />
-        <ToolPalette />
-      </ToolProvider>
-    );
-  const seg = (which: 'preview' | 'edit' | 'present'): HTMLButtonElement | null =>
-    document.querySelector(`[data-testid="palette-mode-${which}"]`);
-
-  test('renders three icon segments; Edit is pressed on boot; no browse/move tool buttons', () => {
-    mountPalette();
-    expect(seg('preview')).not.toBeNull();
-    expect(seg('edit')?.getAttribute('aria-pressed')).toBe('true');
-    expect(seg('preview')?.getAttribute('aria-pressed')).toBe('false');
-    // Owner steer 2026-08-15 — icon-only segments (lucide eye / pencil-ruler /
-    // presentation); the words live in aria-label/title.
-    expect(seg('preview')?.querySelector('svg')).not.toBeNull();
-    expect(seg('edit')?.querySelector('svg')).not.toBeNull();
-    expect(seg('present')?.querySelector('svg')).not.toBeNull();
-    // The segments ARE the resting-tool affordances — no separate Select /
-    // Browse buttons in the nav group.
-    expect(document.querySelector('[aria-label^="Select (V)"]')).toBeNull();
-    expect(document.querySelector('[aria-label^="Browse ("]')).toBeNull();
-    // Present moved INTO the toggle — exactly one presentation affordance, and
-    // it is the segment (the palette's right-end button is gone).
-    const present = document.querySelectorAll('[aria-label^="Presentation mode"]');
-    expect(present.length).toBe(1);
-    expect(present[0]).toBe(seg('present') as Element);
-    expect(seg('present')?.getAttribute('aria-pressed')).toBe('false');
-  });
-
-  test('clicking Preview flips the posture; insert (+) is edit-only', () => {
-    mountPalette();
-    expect(
-      document.querySelector('[aria-label="Insert element — Div, Text, or Image"]')
-    ).not.toBeNull();
-    act(() => {
-      seg('preview')?.click();
-    });
-    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
-    expect(seg('preview')?.getAttribute('aria-pressed')).toBe('true');
-    expect(
-      document.querySelector('[aria-label="Insert element — Div, Text, or Image"]')
-    ).toBeNull();
-    // Draw tools stay available in preview (issue #93: annotations in preview).
-    expect(document.querySelector('[aria-label^="Pen (B)"]')).not.toBeNull();
-    // And the Edit segment arms move again.
-    act(() => {
-      seg('edit')?.click();
-    });
-    expect(pair()).toEqual({ tool: 'move', mode: 'edit' });
-  });
-
-  test('clicking the ACTIVE segment re-arms the resting tool', () => {
-    mountPalette();
-    act(() => {
-      seg('preview')?.click();
-    });
-    act(() => ctx?.setTool('pen'));
-    expect(pair()).toEqual({ tool: 'pen', mode: 'preview' });
-    act(() => {
-      seg('preview')?.click();
-    });
-    expect(pair()).toEqual({ tool: 'browse', mode: 'preview' });
-  });
-});

package/apps/studio/test/motion-sample.test.ts

@@ -1,35 +0,0 @@
-// Unit cover for the live-motion proof sampler's pure delta test. The browser
-// drive itself is integration-shape (needs Chromium + a running dev server);
-// here we pin the `signatureChanged` classifier that decides motion-proven vs
-// dead-mechanism, so a regression can't silently turn a freeze-frame "pass"
-// into a false motion confirmation (DDR-094 M1).
-
-import { describe, expect, test } from 'bun:test';
-import { signatureChanged } from '../bin/_motion-sample-playwright.mjs';
-
-const base = { x: 10, y: 10, width: 80, height: 80, transform: 'none', opacity: 1 };
-
-describe('signatureChanged', () => {
-  test('identical samples ⇒ no change (dead mechanism)', () => {
-    expect(signatureChanged(base, { ...base })).toBe(false);
-  });
-  test('a bbox shift (morph/scale/translate) ⇒ change', () => {
-    expect(signatureChanged(base, { ...base, width: 92 })).toBe(true);
-  });
-  test('a transform-matrix change ⇒ change (rotate/scale via CSS)', () => {
-    expect(signatureChanged(base, { ...base, transform: 'matrix(1,0.2,0,1,0,0)' })).toBe(true);
-  });
-  test('an opacity fade ⇒ change (no bbox delta)', () => {
-    expect(signatureChanged(base, { ...base, opacity: 0.4 })).toBe(true);
-  });
-  test('sub-epsilon numeric jitter is NOT a change (anti-flake)', () => {
-    expect(signatureChanged(base, { ...base, x: 10.1 })).toBe(false);
-    expect(signatureChanged(base, { ...base, x: 10.1 }, 0.05)).toBe(true); // tighter eps catches it
-  });
-  test('the internal __missing marker never counts as a change', () => {
-    expect(signatureChanged({ __missing: true }, { __missing: true })).toBe(false);
-  });
-  test('a null sample is not a change (fail closed)', () => {
-    expect(signatureChanged(null, base)).toBe(false);
-  });
-});

package/apps/studio/test/move-artboards-command.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, mock, test } from 'bun:test';
-
-import {
-  type ArtboardLayoutEntry,
-  createMoveArtboardsCommand,
-  diffLayoutPositions,
-} from '../commands/move-artboards-command.ts';
-
-const A: ArtboardLayoutEntry = { id: 'a', x: 0, y: 0, w: 100, h: 80 };
-const B: ArtboardLayoutEntry = { id: 'b', x: 200, y: 0, w: 100, h: 80 };
-const A2: ArtboardLayoutEntry = { id: 'a', x: 50, y: 25, w: 100, h: 80 };
-const B2: ArtboardLayoutEntry = { id: 'b', x: 260, y: 0, w: 100, h: 80 };
-
-describe('createMoveArtboardsCommand', () => {
-  test('do() patches with the AFTER snapshot', async () => {
-    const patchFn = mock(() => {});
-    const cmd = createMoveArtboardsCommand({ before: [A, B], after: [A2, B], patchFn });
-    await cmd.do();
-    expect(patchFn).toHaveBeenCalledTimes(1);
-    const arg = patchFn.mock.calls[0]?.[0];
-    expect(arg).toEqual([A2, B]);
-  });
-
-  test('undo() patches with the BEFORE snapshot', async () => {
-    const patchFn = mock(() => {});
-    const cmd = createMoveArtboardsCommand({ before: [A, B], after: [A2, B], patchFn });
-    await cmd.undo();
-    expect(patchFn).toHaveBeenCalledTimes(1);
-    const arg = patchFn.mock.calls[0]?.[0];
-    expect(arg).toEqual([A, B]);
-  });
-
-  test('redo idempotence — do() twice yields the same patch payload', async () => {
-    const patchFn = mock(() => {});
-    const cmd = createMoveArtboardsCommand({ before: [A, B], after: [A2, B2], patchFn });
-    await cmd.do();
-    await cmd.do();
-    expect(patchFn).toHaveBeenCalledTimes(2);
-    expect(patchFn.mock.calls[0]?.[0]).toEqual([A2, B2]);
-    expect(patchFn.mock.calls[1]?.[0]).toEqual([A2, B2]);
-  });
-
-  test('snapshots are deep-cloned — mutating the source after construction has no effect', async () => {
-    const before: ArtboardLayoutEntry[] = [{ ...A }, { ...B }];
-    const after: ArtboardLayoutEntry[] = [{ ...A2 }, { ...B }];
-    const patchFn = mock(() => {});
-    const cmd = createMoveArtboardsCommand({ before, after, patchFn });
-    // Poison the source arrays in place.
-    // biome-ignore lint/style/noNonNullAssertion: test invariant — arrays literally constructed two lines above
-    after[0]!.x = 9999;
-    // biome-ignore lint/style/noNonNullAssertion: test invariant — arrays literally constructed two lines above
-    before[1]!.y = -777;
-    await cmd.do();
-    expect(patchFn.mock.calls[0]?.[0]).toEqual([A2, B]);
-    await cmd.undo();
-    expect(patchFn.mock.calls[1]?.[0]).toEqual([A, B]);
-  });
-
-  test('label defaults to "move N artboards" with correct count', () => {
-    const cmd = createMoveArtboardsCommand({
-      before: [A, B],
-      after: [A2, B],
-      patchFn: () => {},
-    });
-    expect(cmd.label).toBe('move 1 artboard');
-
-    const cmd2 = createMoveArtboardsCommand({
-      before: [A, B],
-      after: [A2, B2],
-      patchFn: () => {},
-    });
-    expect(cmd2.label).toBe('move 2 artboards');
-  });
-
-  test('label override (equal-spacing wraps with its own copy)', () => {
-    const cmd = createMoveArtboardsCommand({
-      before: [A, B],
-      after: [A2, B2],
-      patchFn: () => {},
-      label: 'equal-space 2 artboards',
-    });
-    expect(cmd.label).toBe('equal-space 2 artboards');
-  });
-});
-
-describe('diffLayoutPositions', () => {
-  test('identical → null (skip push)', () => {
-    expect(diffLayoutPositions([A, B], [A, B])).toBeNull();
-    expect(diffLayoutPositions([A, B], [{ ...A }, { ...B }])).toBeNull();
-  });
-
-  test('1 moved → { changed: 1 }', () => {
-    expect(diffLayoutPositions([A, B], [A2, B])).toEqual({ changed: 1 });
-  });
-
-  test('both moved → { changed: 2 }', () => {
-    expect(diffLayoutPositions([A, B], [A2, B2])).toEqual({ changed: 2 });
-  });
-
-  test('different array lengths → reports max (defensive — real flows align ids)', () => {
-    expect(diffLayoutPositions([A], [A, B])).toEqual({ changed: 2 });
-  });
-
-  test('size-only diff (no position change) → null', () => {
-    const Aresized: ArtboardLayoutEntry = { id: 'a', x: 0, y: 0, w: 200, h: 160 };
-    expect(diffLayoutPositions([A], [Aresized])).toBeNull();
-  });
-});