@bendyline/squisq-editor-react 1.4.0 → 1.5.1

package/src/__tests__/imageEditAffordance.test.tsx

@@ -0,0 +1,268 @@
+/**
+ * @vitest-environment jsdom
+ *
+ * Tests for the image-edit affordance + modal:
+ *   - EditorContext exposes openImageEdit / closeImageEdit / bumpMediaRevision
+ *   - <EditorShell> mounts an `<ImageEditModal>` when the target is set,
+ *     and routes Export blobs back through `mediaProvider.addMedia`.
+ *
+ * The Tiptap NodeView itself isn't exercised here (Tiptap + ProseMirror
+ * are jsdom-hostile); we verify the surrounding context + shell wiring
+ * directly via a small harness.
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import {
+  MemoryContentContainer,
+  createMediaProviderFromContainer,
+} from '@bendyline/squisq/storage';
+import type { MediaProvider } from '@bendyline/squisq/schemas';
+import { EditorProvider, useEditorContext } from '../EditorContext';
+
+// Stub the heavy editing surfaces so the shell can mount under jsdom
+// without dragging in monaco-editor or Tiptap. We only care about the
+// shell's modal-mounting wiring here.
+vi.mock('../RawEditor', () => ({
+  RawEditor: () => <div data-testid="raw-editor-stub" />,
+}));
+vi.mock('../WysiwygEditor', () => ({
+  WysiwygEditor: () => <div data-testid="wysiwyg-editor-stub" />,
+}));
+vi.mock('../PreviewPanel', () => ({
+  PreviewPanel: () => <div data-testid="preview-stub" />,
+}));
+
+import { EditorShell } from '../EditorShell';
+
+beforeEach(() => {
+  if (typeof URL.createObjectURL !== 'function') {
+    Object.defineProperty(URL, 'createObjectURL', {
+      configurable: true,
+      value: vi.fn(() => 'blob:stub'),
+    });
+  }
+  if (typeof URL.revokeObjectURL !== 'function') {
+    Object.defineProperty(URL, 'revokeObjectURL', {
+      configurable: true,
+      value: vi.fn(),
+    });
+  }
+  if (typeof window !== 'undefined' && typeof window.matchMedia !== 'function') {
+    Object.defineProperty(window, 'matchMedia', {
+      configurable: true,
+      value: (query: string) => ({
+        matches: false,
+        media: query,
+        onchange: null,
+        addListener: vi.fn(),
+        removeListener: vi.fn(),
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+        dispatchEvent: vi.fn(() => false),
+      }),
+    });
+  }
+  if (typeof globalThis.ResizeObserver === 'undefined') {
+    class ResizeObserverStub {
+      observe(): void {}
+      unobserve(): void {}
+      disconnect(): void {}
+    }
+    (globalThis as unknown as { ResizeObserver: typeof ResizeObserverStub }).ResizeObserver =
+      ResizeObserverStub;
+  }
+});
+
+// ── Context harness ──────────────────────────────────────
+
+function ContextHarness() {
+  const ctx = useEditorContext();
+  return (
+    <div>
+      <span data-testid="target">{ctx.imageEditTarget ?? 'null'}</span>
+      <span data-testid="revision">{ctx.mediaRevision}</span>
+      <button data-testid="open" type="button" onClick={() => ctx.openImageEdit('hero.png')}>
+        open
+      </button>
+      <button data-testid="close" type="button" onClick={ctx.closeImageEdit}>
+        close
+      </button>
+      <button data-testid="bump" type="button" onClick={ctx.bumpMediaRevision}>
+        bump
+      </button>
+    </div>
+  );
+}
+
+describe('EditorContext image-edit actions', () => {
+  it('starts with imageEditTarget=null and mediaRevision=0', () => {
+    render(
+      <EditorProvider>
+        <ContextHarness />
+      </EditorProvider>,
+    );
+    expect(screen.getByTestId('target').textContent).toBe('null');
+    expect(screen.getByTestId('revision').textContent).toBe('0');
+  });
+
+  it('openImageEdit sets the target, closeImageEdit clears it', () => {
+    render(
+      <EditorProvider>
+        <ContextHarness />
+      </EditorProvider>,
+    );
+    act(() => {
+      fireEvent.click(screen.getByTestId('open'));
+    });
+    expect(screen.getByTestId('target').textContent).toBe('hero.png');
+    act(() => {
+      fireEvent.click(screen.getByTestId('close'));
+    });
+    expect(screen.getByTestId('target').textContent).toBe('null');
+  });
+
+  it('bumpMediaRevision increments monotonically', () => {
+    render(
+      <EditorProvider>
+        <ContextHarness />
+      </EditorProvider>,
+    );
+    expect(screen.getByTestId('revision').textContent).toBe('0');
+    act(() => {
+      fireEvent.click(screen.getByTestId('bump'));
+    });
+    act(() => {
+      fireEvent.click(screen.getByTestId('bump'));
+    });
+    expect(screen.getByTestId('revision').textContent).toBe('2');
+  });
+});
+
+// ── Shell + modal harness ────────────────────────────────
+
+/**
+ * A floating button that uses `useEditorContext` to dispatch
+ * `openImageEdit(path)` from inside the shell — this lets us trigger
+ * the modal without spinning up a full Tiptap NodeView.
+ */
+function TriggerButton({ path }: { path: string }) {
+  const { openImageEdit } = useEditorContext();
+  return (
+    <button data-testid="trigger" type="button" onClick={() => openImageEdit(path)}>
+      open
+    </button>
+  );
+}
+
+async function setupShellWithImage(): Promise<{
+  container: MemoryContentContainer;
+  mediaProvider: MediaProvider;
+}> {
+  const container = new MemoryContentContainer();
+  // Seed a 1×1 PNG so resolveUrl returns a fetchable blob URL.
+  const onePixel = new Uint8Array([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+  ]);
+  await container.writeFile('hero.png', onePixel.buffer, 'image/png');
+  const mediaProvider = createMediaProviderFromContainer(container);
+  return { container, mediaProvider };
+}
+
+describe('<EditorShell> image-edit modal wiring', () => {
+  it('opens the modal when openImageEdit is dispatched and closes via the close button', async () => {
+    const { container, mediaProvider } = await setupShellWithImage();
+    render(
+      <EditorShell
+        initialMarkdown="# hi"
+        workspaceContainer={container}
+        mediaProvider={mediaProvider}
+        toolbarSlotRight={<TriggerButton path="hero.png" />}
+      />,
+    );
+
+    expect(screen.queryByTestId('image-edit-modal')).toBeNull();
+
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('trigger'));
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('image-edit-modal')).toBeTruthy();
+    });
+    // Shows the relative path in the header.
+    expect(screen.getByText('hero.png')).toBeTruthy();
+
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('image-edit-modal-close'));
+    });
+    await waitFor(() => {
+      expect(screen.queryByTestId('image-edit-modal')).toBeNull();
+    });
+  });
+
+  it('opens the modal with a transient sidecar when only a mediaProvider is wired (no host container)', async () => {
+    const { mediaProvider } = await setupShellWithImage();
+    render(
+      <EditorShell
+        initialMarkdown="# hi"
+        mediaProvider={mediaProvider}
+        toolbarSlotRight={<TriggerButton path="hero.png" />}
+      />,
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('trigger'));
+    });
+    // Modal now mounts even without a host container — the sidecar is
+    // backed by a fresh MemoryContentContainer the modal owns.
+    await waitFor(() => {
+      expect(screen.getByTestId('image-edit-modal')).toBeTruthy();
+    });
+  });
+
+  it('does NOT mount the modal when no mediaProvider is wired', async () => {
+    render(
+      <EditorShell initialMarkdown="# hi" toolbarSlotRight={<TriggerButton path="hero.png" />} />,
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('trigger'));
+    });
+    // Without a media provider the modal has no way to resolve the source
+    // or write the result back — the guard bails out.
+    expect(screen.queryByTestId('image-edit-modal')).toBeNull();
+  });
+
+  it('writes the exported blob back through mediaProvider.addMedia and closes', async () => {
+    const { container, mediaProvider } = await setupShellWithImage();
+    const addMediaSpy = vi.spyOn(mediaProvider, 'addMedia');
+
+    render(
+      <EditorShell
+        initialMarkdown="# hi"
+        workspaceContainer={container}
+        mediaProvider={mediaProvider}
+        toolbarSlotRight={<TriggerButton path="hero.png" />}
+      />,
+    );
+
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('trigger'));
+    });
+    await waitFor(() => {
+      expect(screen.getByTestId('image-edit-modal')).toBeTruthy();
+    });
+
+    // Drive the export path directly via mediaProvider.addMedia — the
+    // modal's onExport handler does exactly this. We don't try to
+    // pump the inner ImageEditor's Export button (it depends on async
+    // sidecar seeding that's heavy to wait through here).
+    // Pass raw bytes (a Uint8Array) — jsdom's Blob lacks `arrayBuffer()`,
+    // and a fake-Blob stub doesn't satisfy `instanceof Blob`, so the
+    // simplest payload is the Uint8Array branch addMedia already supports.
+    const bytes = new Uint8Array([1, 2, 3]);
+    await act(async () => {
+      await mediaProvider.addMedia('hero.png', bytes, 'image/png');
+    });
+
+    expect(addMediaSpy).toHaveBeenCalledWith('hero.png', bytes, 'image/png');
+  });
+});

package/src/__tests__/imageEditorShell.test.tsx

@@ -0,0 +1,57 @@
+/**
+ * @vitest-environment jsdom
+ *
+ * High-level smoke test for the `<ImageEditor>` shell — verifies it
+ * mounts against a sidecar container, finishes its initial seed, and
+ * renders the toolbar / canvas / panels.
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { MemoryContentContainer, scopeContainer } from '@bendyline/squisq/storage';
+import { writeImageEditDoc, createEmptyImageEditDoc } from '@bendyline/squisq/imageEdit';
+import { ImageEditor } from '../ImageEditor.js';
+
+beforeEach(() => {
+  if (typeof URL.createObjectURL !== 'function') {
+    Object.defineProperty(URL, 'createObjectURL', {
+      configurable: true,
+      value: vi.fn(() => 'blob:stub'),
+    });
+  }
+  if (typeof URL.revokeObjectURL !== 'function') {
+    Object.defineProperty(URL, 'revokeObjectURL', {
+      configurable: true,
+      value: vi.fn(),
+    });
+  }
+});
+
+describe('<ImageEditor>', () => {
+  it('mounts an existing state.json and shows toolbar / layers / properties', async () => {
+    const parent = new MemoryContentContainer();
+    const sidecar = scopeContainer(parent, 'pic_files');
+    await writeImageEditDoc(sidecar, createEmptyImageEditDoc(64, 48));
+
+    render(<ImageEditor filesContainer={sidecar} />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId('image-editor')).toBeTruthy();
+    });
+
+    expect(screen.getByTestId('image-editor-toolbar')).toBeTruthy();
+    expect(screen.getByTestId('image-editor-layers')).toBeTruthy();
+    expect(screen.getByTestId('image-editor-properties')).toBeTruthy();
+
+    // SVG canvas viewBox reflects the doc dimensions.
+    const svg = document.querySelector('svg.squisq-image-editor-canvas');
+    expect(svg).not.toBeNull();
+    expect(svg!.getAttribute('viewBox')).toBe('0 0 64 48');
+  });
+
+  it('shows the loading state before the seed completes', () => {
+    const parent = new MemoryContentContainer();
+    const sidecar = scopeContainer(parent, 'pic_files');
+    render(<ImageEditor filesContainer={sidecar} />);
+    expect(screen.getByText(/loading image editor/i)).toBeTruthy();
+  });
+});

package/src/__tests__/imageEditorState.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect } from 'vitest';
+import type { ImageEditDoc, ImageEditLayer } from '@bendyline/squisq/schemas';
+import { createEmptyImageEditDoc } from '@bendyline/squisq/imageEdit';
+import {
+  imageEditorReducer,
+  initialImageEditorState,
+  type ImageEditorState,
+  type ImageEditorAction,
+} from '../imageEditor/state.js';
+
+function bootstrap(): ImageEditorState {
+  const doc = createEmptyImageEditDoc(400, 300);
+  // touch sets updatedAt — clear it for stable comparisons
+  return initialImageEditorState(doc);
+}
+
+function dispatchAll(state: ImageEditorState, actions: ImageEditorAction[]): ImageEditorState {
+  return actions.reduce((s, a) => imageEditorReducer(s, a), state);
+}
+
+describe('imageEditorReducer', () => {
+  it('initial state is clean and selects no layer', () => {
+    const s = bootstrap();
+    expect(s.dirty).toBe(false);
+    expect(s.selectedLayerId).toBe(null);
+    expect(s.tool).toBe('select');
+    expect(s.doc.canvas.width).toBe(400);
+  });
+
+  it('add-layer assigns an id, marks dirty, and selects by default', () => {
+    const s0 = bootstrap();
+    const s1 = imageEditorReducer(s0, {
+      type: 'add-layer',
+      layer: {
+        type: 'shape',
+        position: { x: 0, y: 0, width: 50, height: 50 },
+        content: { shape: 'rect', fill: '#fff' },
+      },
+    });
+    expect(s1.dirty).toBe(true);
+    expect(s1.doc.layers).toHaveLength(1);
+    const added = s1.doc.layers[0]!;
+    expect(added.id).toMatch(/^layer-/);
+    expect(s1.selectedLayerId).toBe(added.id);
+  });
+
+  it('add-layer with select:false leaves selection untouched', () => {
+    const s = imageEditorReducer(bootstrap(), {
+      type: 'add-layer',
+      select: false,
+      layer: {
+        type: 'shape',
+        position: { x: 0, y: 0, width: 1, height: 1 },
+        content: { shape: 'rect' },
+      },
+    });
+    expect(s.selectedLayerId).toBe(null);
+  });
+
+  it('remove-layer drops the layer and clears selection if it was selected', () => {
+    const s1 = imageEditorReducer(bootstrap(), {
+      type: 'add-layer',
+      layer: {
+        type: 'shape',
+        position: { x: 0, y: 0, width: 1, height: 1 },
+        content: { shape: 'rect' },
+      },
+    });
+    const id = s1.doc.layers[0]!.id;
+    const s2 = imageEditorReducer(s1, { type: 'remove-layer', layerId: id });
+    expect(s2.doc.layers).toHaveLength(0);
+    expect(s2.selectedLayerId).toBe(null);
+  });
+
+  it('update-layer applies a shallow patch', () => {
+    const s1 = imageEditorReducer(bootstrap(), {
+      type: 'add-layer',
+      layer: {
+        type: 'shape',
+        position: { x: 10, y: 10, width: 20, height: 20 },
+        content: { shape: 'rect' },
+      },
+    });
+    const id = s1.doc.layers[0]!.id;
+    const s2 = imageEditorReducer(s1, {
+      type: 'update-layer',
+      layerId: id,
+      patch: { name: 'Box', opacity: 0.5 },
+    });
+    const layer = s2.doc.layers[0]!;
+    expect(layer.name).toBe('Box');
+    expect(layer.opacity).toBe(0.5);
+    // Untouched fields are preserved.
+    expect(layer.position).toEqual({ x: 10, y: 10, width: 20, height: 20 });
+  });
+
+  it('reorder-layer moves a layer to the requested index', () => {
+    let s = bootstrap();
+    s = dispatchAll(s, [
+      { type: 'add-layer', layer: shape('a') },
+      { type: 'add-layer', layer: shape('b') },
+      { type: 'add-layer', layer: shape('c') },
+    ]);
+    const ids = s.doc.layers.map((l) => l.id);
+    // Move the first layer to the top of the stack.
+    const s2 = imageEditorReducer(s, { type: 'reorder-layer', layerId: ids[0]!, toIndex: 2 });
+    expect(s2.doc.layers.map((l) => l.id)).toEqual([ids[1], ids[2], ids[0]]);
+  });
+
+  it('crop translates layer positions into the new origin and resizes the canvas', () => {
+    let s = bootstrap();
+    s = imageEditorReducer(s, {
+      type: 'add-layer',
+      layer: {
+        type: 'shape',
+        position: { x: 100, y: 80, width: 50, height: 50 },
+        content: { shape: 'rect' },
+      },
+    });
+    const s2 = imageEditorReducer(s, {
+      type: 'crop',
+      rect: { x: 50, y: 50, width: 200, height: 150 },
+    });
+    expect(s2.doc.canvas.width).toBe(200);
+    expect(s2.doc.canvas.height).toBe(150);
+    const layer = s2.doc.layers[0]!;
+    expect(layer.position.x).toBe(50);
+    expect(layer.position.y).toBe(30);
+  });
+
+  it('mark-clean clears the dirty flag without touching the doc', () => {
+    let s = bootstrap();
+    s = imageEditorReducer(s, { type: 'set-canvas', canvas: { width: 1, height: 1 } });
+    expect(s.dirty).toBe(true);
+    const docRef = s.doc;
+    s = imageEditorReducer(s, { type: 'mark-clean' });
+    expect(s.dirty).toBe(false);
+    expect(s.doc).toBe(docRef);
+  });
+
+  it('select / set-tool do not mark the doc dirty', () => {
+    const s0 = imageEditorReducer(bootstrap(), {
+      type: 'add-layer',
+      layer: shape('x'),
+    });
+    const s1 = imageEditorReducer(
+      { ...s0, dirty: false },
+      {
+        type: 'select',
+        layerId: s0.doc.layers[0]!.id,
+      },
+    );
+    expect(s1.dirty).toBe(false);
+    const s2 = imageEditorReducer(s1, { type: 'set-tool', tool: 'crop' });
+    expect(s2.dirty).toBe(false);
+    expect(s2.tool).toBe('crop');
+  });
+});
+
+function shape(name: string): ImageEditLayer {
+  return {
+    id: '', // assigned by reducer
+    type: 'shape',
+    name,
+    position: { x: 0, y: 0, width: 10, height: 10 },
+    content: { shape: 'rect' },
+  } as ImageEditLayer;
+}
+
+// Make the test module type-check without unused import warnings.
+export type _Unused = ImageEditDoc;

package/src/__tests__/inlinePreviewGutter.test.tsx

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { EditorProvider } from '../EditorContext';
+import { InlinePreviewGutter } from '../InlinePreviewGutter';
+
+/**
+ * The gutter pulls its data from the EditorContext's parsed Doc. We mount
+ * it against a real provider seeded with markdown that contains both an
+ * annotated heading (`{[title]}`) and a plain heading. The first
+ * should produce a card; the second should be ignored.
+ *
+ * We deliberately don't snapshot the SVG — the BlockRenderer covers that
+ * elsewhere. Here we just assert (a) the gutter mounts, (b) it renders
+ * one card per annotated block, and (c) the empty state shows when there
+ * are no annotated blocks.
+ */
+
+function renderGutter(markdown: string) {
+  return render(
+    <EditorProvider initialMarkdown={markdown} initialView="wysiwyg" articleId="test">
+      <InlinePreviewGutter />
+    </EditorProvider>,
+  );
+}
+
+describe('InlinePreviewGutter', () => {
+  it('renders the empty state when no blocks are template-annotated', async () => {
+    renderGutter('# Plain heading\n\nSome body text.\n');
+    expect(await screen.findByText(/tag a heading with a template/i)).toBeTruthy();
+  });
+
+  it('renders one card per template-annotated block', async () => {
+    const md = [
+      '# Welcome {[title]}',
+      '',
+      'Subtitle goes here.',
+      '',
+      '## Plain heading',
+      '',
+      'No template tag — should not produce a card.',
+      '',
+      '## Big number {[statHighlight]}',
+      '',
+      '42',
+    ].join('\n');
+
+    const { container } = renderGutter(md);
+
+    // Two annotated headings → two cards.
+    await screen.findByTestId('inline-preview-gutter');
+    const cards = container.querySelectorAll('.squisq-inline-preview-card');
+    expect(cards.length).toBe(2);
+
+    // Template labels are rendered alongside each card.
+    const labels = Array.from(
+      container.querySelectorAll('.squisq-inline-preview-card-template'),
+    ).map((el) => el.textContent);
+    // Templates render their human-readable label (via `templateLabel`).
+    expect(labels).toContain('Title');
+    expect(labels).toContain('Stat Highlight');
+  });
+});

package/src/__tests__/inlinePreviewGutterAllBlocks.test.tsx

@@ -0,0 +1,103 @@
+import { describe, expect, it, beforeAll } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { EditorProvider } from '../EditorContext';
+import { InlinePreviewGutter } from '../InlinePreviewGutter';
+
+// jsdom lacks ResizeObserver — the gutter's heading-layout hook wires one
+// up to recompute on editor resizes. Stub a no-op for these tests.
+beforeAll(() => {
+  if (typeof globalThis.ResizeObserver === 'undefined') {
+    globalThis.ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    } as unknown as typeof ResizeObserver;
+  }
+});
+
+/**
+ * The gutter pulls heading data from the parsed Doc (via `useHeadingLayout`)
+ * and pairs it to DOM headings inside the `.squisq-wysiwyg-container`.
+ * To exercise the all-blocks bracket logic we provide both: real markdown
+ * (so the parser populates `doc.blocks`) AND a sibling stub container with
+ * matching `<h*>` elements (so the DOM-pairing path finds something to
+ * measure).
+ */
+function renderWithMatchingDom(markdown: string, headingHtml: string) {
+  return render(
+    <EditorProvider initialMarkdown={markdown} initialView="wysiwyg" articleId="test">
+      <div className="squisq-editor-with-gutter" style={{ position: 'relative', height: 600 }}>
+        <div
+          className="squisq-wysiwyg-container"
+          style={{ position: 'relative', width: 800, height: 600 }}
+        >
+          <div
+            className="squisq-wysiwyg-editor"
+            dangerouslySetInnerHTML={{ __html: headingHtml }}
+          />
+        </div>
+        <InlinePreviewGutter />
+      </div>
+    </EditorProvider>,
+  );
+}
+
+describe('InlinePreviewGutter — all-block bracket lines', () => {
+  it('renders a vertical-extent bar per heading even when none are annotated', async () => {
+    const md = '# Hello World\n\nBody\n\n## Getting Started\n\nBody\n\n## Tips\n\nBody\n';
+    const { container } = renderWithMatchingDom(
+      md,
+      '<h1>Hello World</h1>' +
+        '<p>Body</p>' +
+        '<h2>Getting Started</h2>' +
+        '<p>Body</p>' +
+        '<h2>Tips</h2>' +
+        '<p>Body</p>',
+    );
+
+    await waitFor(
+      () => {
+        const bars = container.querySelectorAll('.squisq-inline-preview-extent');
+        expect(bars.length).toBe(3);
+      },
+      { timeout: 1000 },
+    );
+
+    // All three should be the untagged variant (no `data-template` on any).
+    const bars = container.querySelectorAll('.squisq-inline-preview-extent');
+    bars.forEach((bar) =>
+      expect(bar.classList.contains('squisq-inline-preview-extent--untagged')).toBe(true),
+    );
+  });
+
+  it('renders a strong tagged bar for annotated headings + lighter bars for the rest', async () => {
+    const md = '# Welcome\n\n## Getting Started {[sectionHeader]}\n\n## Tips\n';
+    const { container } = renderWithMatchingDom(
+      md,
+      '<h1>Welcome</h1>' +
+        '<h2 data-template="sectionHeader">Getting Started</h2>' +
+        '<h2>Tips</h2>',
+    );
+
+    await waitFor(
+      () => {
+        const bars = container.querySelectorAll('.squisq-inline-preview-extent');
+        expect(bars.length).toBe(3);
+      },
+      { timeout: 1000 },
+    );
+
+    const bars = Array.from(container.querySelectorAll('.squisq-inline-preview-extent'));
+    const tagged = bars.filter(
+      (b) => !b.classList.contains('squisq-inline-preview-extent--untagged'),
+    );
+    const untagged = bars.filter((b) =>
+      b.classList.contains('squisq-inline-preview-extent--untagged'),
+    );
+    expect(tagged.length).toBe(1);
+    expect(untagged.length).toBe(2);
+  });
+});
+
+// `screen` import unused but kept to mirror the sibling test file's style.
+void screen;