@syntrologie/adapt-nav 2.4.1 → 2.5.1

package/node_modules/@syntrologie/sdk-contracts/dist/schemas.js

@@ -6,6 +6,15 @@
  */
 import { z } from 'zod';
 // =============================================================================
+// ANCHOR ID SCHEMA
+// =============================================================================
+export const AnchorIdZ = z
+    .object({
+    selector: z.string(),
+    route: z.union([z.string(), z.array(z.string())]),
+})
+    .strict();
+// =============================================================================
 // CONDITION SCHEMAS
 // =============================================================================
 export const PageUrlConditionZ = z.object({
@@ -60,12 +69,21 @@ export const FrequencyLimitConditionZ = z.object({
     limit: z.number(),
     inverted: z.boolean().optional(),
 });
+export const MatchOpZ = z.object({
+    equals: z.union([z.string(), z.number(), z.boolean()]).optional(),
+    contains: z.string().optional(),
+});
+export const CounterDefZ = z.object({
+    events: z.array(z.string()).min(1),
+    match: z.record(z.string(), MatchOpZ).optional(),
+});
 export const EventCountConditionZ = z.object({
     type: z.literal('event_count'),
     key: z.string(),
     operator: z.enum(['gte', 'lte', 'eq', 'gt', 'lt']),
     count: z.number().int().min(0),
     withinMs: z.number().positive().optional(),
+    counter: CounterDefZ.optional(),
 });
 export const ConditionZ = z.discriminatedUnion('type', [
     PageUrlConditionZ,
@@ -119,6 +137,8 @@ export const DecisionStrategyZ = z.discriminatedUnion('type', [
     ModelStrategyZ,
     ExternalStrategyZ,
 ]);
+/** Canonical Zod schema for the optional triggerWhen field on actions and adaptive items. */
+export const TriggerWhenZ = DecisionStrategyZ.nullable().optional();
 // =============================================================================
 // EVENT SCOPE SCHEMA
 // =============================================================================
@@ -131,7 +151,7 @@ export const EventScopeZ = z.object({
 // =============================================================================
 // NOTIFY SCHEMA
 // =============================================================================
-/** Toast notification config for showWhen transitions. */
+/** Toast notification config for triggerWhen transitions. */
 export const NotifyZ = z
     .object({
     title: z.string().optional(),

package/node_modules/@syntrologie/shared-editor-ui/dist/__tests__/AnchorPicker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AnchorPicker.test.d.ts.map

package/node_modules/@syntrologie/shared-editor-ui/dist/__tests__/AnchorPicker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnchorPicker.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/AnchorPicker.test.tsx"],"names":[],"mappings":""}

package/node_modules/@syntrologie/shared-editor-ui/dist/__tests__/AnchorPicker.test.js

@@ -0,0 +1,224 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { act, render } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { AnchorPicker } from '../components/AnchorPicker';
+// Mock ResizeObserver for jsdom
+vi.stubGlobal('ResizeObserver', class {
+    observe() { }
+    unobserve() { }
+    disconnect() { }
+});
+// Mock selectorGenerator utilities
+vi.mock('../utils/selectorGenerator', () => ({
+    generateSelector: vi.fn((el) => `mock-selector-${el.tagName.toLowerCase()}`),
+    validateSelector: vi.fn(() => true),
+    getElementDescription: vi.fn((el) => `mock-desc-${el.tagName.toLowerCase()}`),
+}));
+import { generateSelector, getElementDescription, validateSelector, } from '../utils/selectorGenerator';
+describe('AnchorPicker', () => {
+    let mockElementAtPoint;
+    beforeEach(() => {
+        mockElementAtPoint = document.createElement('div');
+        mockElementAtPoint.textContent = 'Target Element';
+        document.body.appendChild(mockElementAtPoint);
+        vi.spyOn(mockElementAtPoint, 'getBoundingClientRect').mockReturnValue({
+            top: 100,
+            left: 200,
+            width: 300,
+            height: 150,
+            bottom: 250,
+            right: 500,
+            x: 200,
+            y: 100,
+            toJSON: () => ({}),
+        });
+        vi.mocked(generateSelector).mockClear();
+        vi.mocked(validateSelector).mockClear();
+        vi.mocked(getElementDescription).mockClear();
+        vi.mocked(generateSelector).mockImplementation((el) => `mock-selector-${el.tagName.toLowerCase()}`);
+        vi.mocked(validateSelector).mockReturnValue(true);
+        vi.mocked(getElementDescription).mockImplementation((el) => `mock-desc-${el.tagName.toLowerCase()}`);
+        // Stub elementFromPoint on document (jsdom does not define it)
+        if (!document.elementFromPoint) {
+            document.elementFromPoint = vi.fn(() => null);
+        }
+        else {
+            vi.spyOn(document, 'elementFromPoint').mockReturnValue(null);
+        }
+    });
+    afterEach(() => {
+        if (mockElementAtPoint.parentNode) {
+            mockElementAtPoint.remove();
+        }
+        vi.restoreAllMocks();
+    });
+    it('renders nothing when isActive is false', () => {
+        render(_jsx(AnchorPicker, { isActive: false, onPick: vi.fn(), onCancel: vi.fn() }));
+        const picker = document.body.querySelector('[data-syntro-anchor-picker]');
+        expect(picker).toBeNull();
+    });
+    it('renders overlay portal to document.body when active', () => {
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        const picker = document.body.querySelector('[data-syntro-anchor-picker]');
+        expect(picker).toBeTruthy();
+        unmount();
+    });
+    it('sets crosshair cursor on overlay', () => {
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        const picker = document.body.querySelector('[data-syntro-anchor-picker]');
+        expect(picker.style.cursor).toBe('crosshair');
+        unmount();
+    });
+    it('sets highest z-index on overlay', () => {
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        const picker = document.body.querySelector('[data-syntro-anchor-picker]');
+        expect(picker.style.zIndex).toBe('2147483644');
+        unmount();
+    });
+    it('calls onCancel when Escape key is pressed', () => {
+        const onCancel = vi.fn();
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: onCancel }));
+        act(() => {
+            document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+        });
+        expect(onCancel).toHaveBeenCalledTimes(1);
+        unmount();
+    });
+    it('does not call onCancel for non-Escape keys', () => {
+        const onCancel = vi.fn();
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: onCancel }));
+        act(() => {
+            document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+        });
+        expect(onCancel).not.toHaveBeenCalled();
+        unmount();
+    });
+    it('highlights element on mousemove via elementFromPoint', () => {
+        document.elementFromPoint.mockReturnValue(mockElementAtPoint);
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        act(() => {
+            document.dispatchEvent(new MouseEvent('mousemove', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        // generateSelector should have been called with the element
+        expect(generateSelector).toHaveBeenCalledWith(mockElementAtPoint);
+        unmount();
+    });
+    it('clears hover state when elementFromPoint returns null', () => {
+        document.elementFromPoint.mockReturnValue(null);
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        act(() => {
+            document.dispatchEvent(new MouseEvent('mousemove', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        // No highlight should be shown (just the overlay container + the semi-transparent bg div)
+        const picker = document.body.querySelector('[data-syntro-anchor-picker]');
+        expect(picker.children.length).toBe(1);
+        unmount();
+    });
+    it('excludes editor panel elements from picking', () => {
+        const editorPanel = document.createElement('div');
+        editorPanel.setAttribute('data-syntro-editor-panel', '');
+        const innerEl = document.createElement('span');
+        editorPanel.appendChild(innerEl);
+        document.body.appendChild(editorPanel);
+        document.elementFromPoint.mockReturnValue(innerEl);
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        act(() => {
+            document.dispatchEvent(new MouseEvent('mousemove', { clientX: 100, clientY: 100, bubbles: true }));
+        });
+        // Should not call generateSelector for excluded elements
+        expect(generateSelector).not.toHaveBeenCalled();
+        editorPanel.remove();
+        unmount();
+    });
+    it('excludes HTML, BODY, HEAD elements from picking', () => {
+        document.elementFromPoint.mockReturnValue(document.body);
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        act(() => {
+            document.dispatchEvent(new MouseEvent('mousemove', { clientX: 100, clientY: 100, bubbles: true }));
+        });
+        expect(generateSelector).not.toHaveBeenCalled();
+        unmount();
+    });
+    it('calls onPick with valid selector on click after hover', () => {
+        const onPick = vi.fn();
+        document.elementFromPoint.mockReturnValue(mockElementAtPoint);
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: onPick, onCancel: vi.fn() }));
+        // First hover to set the hovered element
+        act(() => {
+            document.dispatchEvent(new MouseEvent('mousemove', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        // Then click
+        act(() => {
+            document.dispatchEvent(new MouseEvent('click', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        expect(onPick).toHaveBeenCalledTimes(1);
+        expect(onPick).toHaveBeenCalledWith({
+            element: mockElementAtPoint,
+            selector: 'mock-selector-div',
+            description: 'mock-desc-div',
+        });
+        unmount();
+    });
+    it('regenerates selector when validation fails on click', () => {
+        const onPick = vi.fn();
+        document.elementFromPoint.mockReturnValue(mockElementAtPoint);
+        vi.mocked(validateSelector).mockReturnValue(false);
+        vi.mocked(generateSelector).mockReturnValue('regenerated-selector');
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: onPick, onCancel: vi.fn() }));
+        // Hover to set element
+        act(() => {
+            document.dispatchEvent(new MouseEvent('mousemove', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        // Click
+        act(() => {
+            document.dispatchEvent(new MouseEvent('click', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        expect(onPick).toHaveBeenCalledWith(expect.objectContaining({
+            selector: 'regenerated-selector',
+        }));
+        unmount();
+    });
+    it('does not call onPick when no element is hovered on click', () => {
+        const onPick = vi.fn();
+        document.elementFromPoint.mockReturnValue(null);
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: onPick, onCancel: vi.fn() }));
+        act(() => {
+            document.dispatchEvent(new MouseEvent('click', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        expect(onPick).not.toHaveBeenCalled();
+        unmount();
+    });
+    it('removes event listeners when deactivated', () => {
+        const onCancel = vi.fn();
+        const { rerender, unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: onCancel }));
+        // Deactivate
+        rerender(_jsx(AnchorPicker, { isActive: false, onPick: vi.fn(), onCancel: onCancel }));
+        // Escape should not trigger onCancel after deactivation
+        act(() => {
+            document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+        });
+        expect(onCancel).not.toHaveBeenCalled();
+        unmount();
+    });
+    it('temporarily disables pointer events on overlay during mousemove detection', () => {
+        const overlayPointerEvents = [];
+        document.elementFromPoint.mockImplementation(() => {
+            // Capture overlay pointer events state during elementFromPoint call
+            const overlay = document.body.querySelector('[data-syntro-anchor-picker]');
+            if (overlay) {
+                overlayPointerEvents.push(overlay.style.pointerEvents);
+            }
+            return mockElementAtPoint;
+        });
+        const { unmount } = render(_jsx(AnchorPicker, { isActive: true, onPick: vi.fn(), onCancel: vi.fn() }));
+        act(() => {
+            document.dispatchEvent(new MouseEvent('mousemove', { clientX: 250, clientY: 150, bubbles: true }));
+        });
+        // During elementFromPoint, overlay pointerEvents should be 'none'
+        expect(overlayPointerEvents).toContain('none');
+        // After the call, it should be restored to 'auto'
+        const overlay = document.body.querySelector('[data-syntro-anchor-picker]');
+        expect(overlay.style.pointerEvents).toBe('auto');
+        unmount();
+    });
+});

package/node_modules/@syntrologie/shared-editor-ui/dist/__tests__/ConditionStatusLine.test.js

@@ -155,4 +155,106 @@ describe('ConditionStatusLine', () => {
         expect(label.className).toContain('se-text-text-secondary');
         expect(label.className).not.toContain('se-text-text-tertiary');
     });
+    it('renders progress bar for single condition with progress data', () => {
+        const status = {
+            visible: false,
+            isFallback: false,
+            conditions: [
+                {
+                    type: 'event_count',
+                    passed: false,
+                    formatted: {
+                        label: 'views >= 5',
+                        instruction: 'View pages 5+ times',
+                        shortLabel: 'View 5+ times',
+                        progress: { current: 2, target: 5, operator: 'gte' },
+                    },
+                },
+            ],
+        };
+        const { container } = render(_jsx(ConditionStatusLine, { status: status }));
+        // Progress bar has a title with current/target
+        const progressBar = container.querySelector('[title]');
+        expect(progressBar).toBeTruthy();
+        expect(progressBar.title).toContain('2/5');
+        // Also shows numeric progress
+        expect(screen.getByText('2/5')).toBeTruthy();
+    });
+    it('renders progress bar at 100% with green color', () => {
+        const status = {
+            visible: true,
+            isFallback: false,
+            conditions: [
+                {
+                    type: 'event_count',
+                    passed: true,
+                    formatted: {
+                        label: 'clicks >= 3',
+                        instruction: 'Click 3+ times',
+                        shortLabel: '3+ clicks',
+                        progress: { current: 5, target: 3, operator: 'gte' },
+                    },
+                },
+            ],
+        };
+        const { container } = render(_jsx(ConditionStatusLine, { status: status }));
+        const progressBar = container.querySelector('[title]');
+        expect(progressBar).toBeTruthy();
+        // 100% cap
+        expect(progressBar.title).toContain('100%');
+        // The inner bar should have green background
+        const innerBar = progressBar.firstElementChild;
+        expect(innerBar.className).toContain('se-bg-green-4');
+    });
+    it('renders progress bar with blue color when not at 100%', () => {
+        const status = {
+            visible: false,
+            isFallback: false,
+            conditions: [
+                {
+                    type: 'event_count',
+                    passed: false,
+                    formatted: {
+                        label: 'clicks >= 10',
+                        instruction: 'Click 10+ times',
+                        shortLabel: '10+ clicks',
+                        progress: { current: 3, target: 10, operator: 'gte' },
+                    },
+                },
+            ],
+        };
+        const { container } = render(_jsx(ConditionStatusLine, { status: status }));
+        const progressBar = container.querySelector('[title]');
+        const innerBar = progressBar.firstElementChild;
+        expect(innerBar.className).toContain('se-bg-blue-4');
+        expect(innerBar.className).not.toContain('se-bg-green-4');
+    });
+    it('renders progress bar in expanded multi-condition rows', () => {
+        const status = {
+            visible: false,
+            isFallback: false,
+            conditions: [
+                {
+                    type: 'page_url',
+                    passed: true,
+                    formatted: { label: '/p', instruction: 'A', shortLabel: 'A' },
+                },
+                {
+                    type: 'event_count',
+                    passed: false,
+                    formatted: {
+                        label: 'views >= 5',
+                        instruction: 'B',
+                        shortLabel: 'B',
+                        progress: { current: 2, target: 5, operator: 'gte' },
+                    },
+                },
+            ],
+        };
+        render(_jsx(ConditionStatusLine, { status: status }));
+        // Expand
+        fireEvent.click(screen.getByText('1 of 2 conditions met'));
+        // Progress bar should appear in the expanded section
+        expect(screen.getByText('2/5')).toBeTruthy();
+    });
 });

package/node_modules/@syntrologie/shared-editor-ui/dist/__tests__/DetectionBadge.test.js

@@ -1,18 +1,70 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { render } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
+import { fireEvent, render } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
 import { DetectionBadge } from '../components/DetectionBadge';
 describe('DetectionBadge', () => {
-    it('shows green dot class when found is true', () => {
+    it('displays "GoTo" text', () => {
+        const { container } = render(_jsx(DetectionBadge, { found: true }));
+        expect(container.textContent).toBe('GoTo');
+    });
+    it('uses green text color when found is true', () => {
         const { container } = render(_jsx(DetectionBadge, { found: true }));
         const badge = container.firstElementChild;
-        expect(badge.className).toContain('se-bg-green-4');
+        expect(badge.className).toContain('se-text-green-4');
         expect(badge.title).toBe('Found on this page');
     });
-    it('shows gray dot class when found is false', () => {
+    it('uses muted text color when found is false', () => {
         const { container } = render(_jsx(DetectionBadge, { found: false }));
         const badge = container.firstElementChild;
-        expect(badge.className).toContain('se-bg-text-tertiary');
+        expect(badge.className).toContain('se-text-text-tertiary');
         expect(badge.title).toBe('Not found on this page');
     });
+    it('renders a <span> when no onClick is provided', () => {
+        const { container } = render(_jsx(DetectionBadge, { found: true }));
+        const badge = container.firstElementChild;
+        expect(badge.tagName).toBe('SPAN');
+    });
+    it('renders a <button> when onClick is provided', () => {
+        const { container } = render(_jsx(DetectionBadge, { found: true, onClick: () => { } }));
+        const badge = container.firstElementChild;
+        expect(badge.tagName).toBe('BUTTON');
+    });
+    it('calls onClick when clicked', () => {
+        const onClick = vi.fn();
+        const { container } = render(_jsx(DetectionBadge, { found: true, onClick: onClick }));
+        const badge = container.firstElementChild;
+        fireEvent.click(badge);
+        expect(onClick).toHaveBeenCalledTimes(1);
+    });
+    it('calls stopPropagation so clicks do not bubble to parent card', () => {
+        const onClick = vi.fn();
+        const parentClick = vi.fn();
+        const { container } = render(
+        // biome-ignore lint/a11y/useKeyWithClickEvents: test wrapper
+        _jsx("div", { onClick: parentClick, children: _jsx(DetectionBadge, { found: false, onClick: onClick }) }));
+        const badge = container.querySelector('button');
+        fireEvent.click(badge);
+        expect(onClick).toHaveBeenCalledTimes(1);
+        expect(parentClick).not.toHaveBeenCalled();
+    });
+    it('shows "Click to scroll to element" title when onClick + found', () => {
+        const { container } = render(_jsx(DetectionBadge, { found: true, onClick: () => { } }));
+        const badge = container.firstElementChild;
+        expect(badge.title).toBe('Click to scroll to element');
+    });
+    it('shows "Click to navigate to page" title when onClick + not found', () => {
+        const { container } = render(_jsx(DetectionBadge, { found: false, onClick: () => { } }));
+        const badge = container.firstElementChild;
+        expect(badge.title).toBe('Click to navigate to page');
+    });
+    it('has green indicator dot when found', () => {
+        const { container } = render(_jsx(DetectionBadge, { found: true }));
+        const dot = container.querySelector('[data-indicator]');
+        expect(dot.className).toContain('se-bg-green-4');
+    });
+    it('has muted indicator dot when not found', () => {
+        const { container } = render(_jsx(DetectionBadge, { found: false }));
+        const dot = container.querySelector('[data-indicator]');
+        expect(dot.className).toContain('se-bg-text-tertiary');
+    });
 });

package/node_modules/@syntrologie/shared-editor-ui/dist/__tests__/DismissedSection.test.js

@@ -25,4 +25,22 @@ describe('DismissedSection', () => {
         fireEvent.click(getByText('Dismissed (1)'));
         expect(queryByText('content')).toBeNull();
     });
+    it('expands on Enter keydown', () => {
+        const { getByText, queryByText } = render(_jsx(DismissedSection, { count: 2, children: _jsx("span", { children: "keyboard content" }) }));
+        const button = getByText('Dismissed (2)').closest('[role="button"]');
+        fireEvent.keyDown(button, { key: 'Enter' });
+        expect(queryByText('keyboard content')).toBeTruthy();
+    });
+    it('expands on Space keydown', () => {
+        const { getByText, queryByText } = render(_jsx(DismissedSection, { count: 2, children: _jsx("span", { children: "space content" }) }));
+        const button = getByText('Dismissed (2)').closest('[role="button"]');
+        fireEvent.keyDown(button, { key: ' ' });
+        expect(queryByText('space content')).toBeTruthy();
+    });
+    it('does not expand on other key presses', () => {
+        const { getByText, queryByText } = render(_jsx(DismissedSection, { count: 2, children: _jsx("span", { children: "other key content" }) }));
+        const button = getByText('Dismissed (2)').closest('[role="button"]');
+        fireEvent.keyDown(button, { key: 'Tab' });
+        expect(queryByText('other key content')).toBeNull();
+    });
 });

package/node_modules/@syntrologie/shared-editor-ui/dist/__tests__/EditorCard.test.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { render } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
+import { fireEvent, render } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
 import { EditorCard } from '../components/EditorCard';
 describe('EditorCard', () => {
     it('renders children', () => {
@@ -22,4 +22,63 @@ describe('EditorCard', () => {
         const card = container.firstElementChild;
         expect(card.className).toContain('se-border-border-primary');
     });
+    it('calls onClick when Enter key is pressed', () => {
+        const onClick = vi.fn();
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", onClick: onClick, children: "child" }));
+        const card = container.firstElementChild;
+        fireEvent.keyDown(card, { key: 'Enter' });
+        expect(onClick).toHaveBeenCalledTimes(1);
+    });
+    it('calls onClick when Space key is pressed', () => {
+        const onClick = vi.fn();
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", onClick: onClick, children: "child" }));
+        const card = container.firstElementChild;
+        fireEvent.keyDown(card, { key: ' ' });
+        expect(onClick).toHaveBeenCalledTimes(1);
+    });
+    it('does not call onClick on other key presses', () => {
+        const onClick = vi.fn();
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", onClick: onClick, children: "child" }));
+        const card = container.firstElementChild;
+        fireEvent.keyDown(card, { key: 'Tab' });
+        expect(onClick).not.toHaveBeenCalled();
+    });
+    it('has role="button" and tabIndex when onClick is provided', () => {
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", onClick: () => { }, children: "child" }));
+        const card = container.firstElementChild;
+        expect(card.getAttribute('role')).toBe('button');
+        expect(card.getAttribute('tabindex')).toBe('0');
+    });
+    it('does not have role or tabIndex when onClick is not provided', () => {
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", children: "child" }));
+        const card = container.firstElementChild;
+        expect(card.getAttribute('role')).toBeNull();
+        expect(card.getAttribute('tabindex')).toBeNull();
+    });
+    it('applies cursor-pointer and hover classes when onClick is provided', () => {
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", onClick: () => { }, children: "child" }));
+        const card = container.firstElementChild;
+        expect(card.className).toContain('se-cursor-pointer');
+        expect(card.className).toContain('hover:se-bg-sidebar-hover');
+    });
+    it('does not apply cursor-pointer when onClick is not provided', () => {
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", children: "child" }));
+        const card = container.firstElementChild;
+        expect(card.className).not.toContain('se-cursor-pointer');
+    });
+    it('calls onMouseEnter and onMouseLeave', () => {
+        const onMouseEnter = vi.fn();
+        const onMouseLeave = vi.fn();
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave, children: "child" }));
+        const card = container.firstElementChild;
+        fireEvent.mouseEnter(card);
+        expect(onMouseEnter).toHaveBeenCalledTimes(1);
+        fireEvent.mouseLeave(card);
+        expect(onMouseLeave).toHaveBeenCalledTimes(1);
+    });
+    it('merges custom className', () => {
+        const { container } = render(_jsx(EditorCard, { itemKey: "k", className: "custom-class", children: "child" }));
+        const card = container.firstElementChild;
+        expect(card.className).toContain('custom-class');
+    });
 });