@syntrologie/adapt-content 2.1.0 → 2.2.0-canary.10

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

@@ -0,0 +1,100 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { fireEvent, render } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ElementHighlight } from '../components/ElementHighlight';
+// Mock ResizeObserver for jsdom
+class MockResizeObserver {
+    observe() { }
+    unobserve() { }
+    disconnect() { }
+}
+vi.stubGlobal('ResizeObserver', MockResizeObserver);
+vi.stubGlobal('requestAnimationFrame', (cb) => {
+    cb(0);
+    return 0;
+});
+vi.stubGlobal('cancelAnimationFrame', () => { });
+describe('ElementHighlight', () => {
+    let mockElement;
+    let mockRect;
+    beforeEach(() => {
+        mockRect = {
+            top: 100,
+            left: 200,
+            width: 300,
+            height: 150,
+            bottom: 250,
+            right: 500,
+            x: 200,
+            y: 100,
+            toJSON: () => ({}),
+        };
+        mockElement = document.createElement('div');
+        vi.spyOn(mockElement, 'getBoundingClientRect').mockReturnValue(mockRect);
+    });
+    it('renders portal to document.body', () => {
+        render(_jsx(ElementHighlight, { element: mockElement, color: "#3b82f6" }));
+        // The highlight is portaled to document.body — check body has the overlay
+        const overlay = document.body.querySelector('[data-syntro-highlight]');
+        expect(overlay).toBeTruthy();
+    });
+    it('positions at element bounding rect', () => {
+        render(_jsx(ElementHighlight, { element: mockElement, color: "#3b82f6", padding: 2 }));
+        const overlay = document.body.querySelector('[data-syntro-highlight]');
+        expect(overlay).toBeTruthy();
+        // Fixed positioning with padding
+        expect(overlay.style.top).toBe('98px'); // 100 - 2
+        expect(overlay.style.left).toBe('198px'); // 200 - 2
+        expect(overlay.style.width).toBe('304px'); // 300 + 2*2
+        expect(overlay.style.height).toBe('154px'); // 150 + 2*2
+    });
+    it('shows label text and icon', () => {
+        const icon = _jsx("span", { "data-testid": "icon", children: "I" });
+        render(_jsx(ElementHighlight, { element: mockElement, color: "#ef4444", label: "Sensitive", labelIcon: icon }));
+        const label = document.body.querySelector('[data-syntro-highlight-label]');
+        expect(label).toBeTruthy();
+        expect(label.textContent).toContain('Sensitive');
+        expect(document.body.querySelector('[data-testid="icon"]')).toBeTruthy();
+    });
+    it('shows remove button when showRemove is true', () => {
+        const onRemove = vi.fn();
+        render(_jsx(ElementHighlight, { element: mockElement, color: "#ef4444", label: "Test", showRemove: true, onRemove: onRemove }));
+        const removeBtn = document.body.querySelector('[data-syntro-highlight-remove]');
+        expect(removeBtn).toBeTruthy();
+    });
+    it('calls onClick when clicked', () => {
+        const onClick = vi.fn();
+        render(_jsx(ElementHighlight, { element: mockElement, color: "#3b82f6", onClick: onClick }));
+        const overlay = document.body.querySelector('[data-syntro-highlight]');
+        fireEvent.click(overlay);
+        expect(onClick).toHaveBeenCalledTimes(1);
+    });
+    it('calls onRemove when remove button is clicked', () => {
+        const onRemove = vi.fn();
+        const onClick = vi.fn();
+        render(_jsx(ElementHighlight, { element: mockElement, color: "#ef4444", label: "Test", showRemove: true, onRemove: onRemove, onClick: onClick }));
+        const removeBtn = document.body.querySelector('[data-syntro-highlight-remove]');
+        fireEvent.click(removeBtn);
+        expect(onRemove).toHaveBeenCalledTimes(1);
+        // onClick should not fire when clicking remove
+        expect(onClick).not.toHaveBeenCalled();
+    });
+    it('shows dimensions when showDimensions is true', () => {
+        mockElement = document.createElement('section');
+        mockElement.id = 'hero';
+        vi.spyOn(mockElement, 'getBoundingClientRect').mockReturnValue(mockRect);
+        render(_jsx(ElementHighlight, { element: mockElement, color: "rgba(99,102,241,0.6)", showDimensions: true }));
+        const label = document.body.querySelector('[data-syntro-highlight-label]');
+        expect(label).toBeTruthy();
+        // Should contain tag name and dimensions
+        expect(label.textContent).toContain('section');
+        expect(label.textContent).toContain('#hero');
+        expect(label.textContent).toContain('300');
+        expect(label.textContent).toContain('150');
+    });
+    it('does not show remove button when showRemove is false', () => {
+        render(_jsx(ElementHighlight, { element: mockElement, color: "#3b82f6", label: "Test" }));
+        const removeBtn = document.body.querySelector('[data-syntro-highlight-remove]');
+        expect(removeBtn).toBeNull();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import { EmptyState } from '../components/EmptyState';
+describe('EmptyState', () => {
+    it('renders the message text', () => {
+        const { getByText } = render(_jsx(EmptyState, { message: "No items found" }));
+        expect(getByText('No items found')).toBeTruthy();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import { GroupHeader } from '../components/GroupHeader';
+describe('GroupHeader', () => {
+    it('renders the label', () => {
+        const { getByText } = render(_jsx(GroupHeader, { label: "Active", count: 5 }));
+        expect(getByText('Active')).toBeTruthy();
+    });
+    it('renders the count badge', () => {
+        const { getByText } = render(_jsx(GroupHeader, { label: "Items", count: 12 }));
+        expect(getByText('12')).toBeTruthy();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,126 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { TriggerJourney } from '../components/TriggerJourney';
+describe('TriggerJourney', () => {
+    it('returns null when status is null', () => {
+        const { container } = render(_jsx(TriggerJourney, { status: null }));
+        expect(container.innerHTML).toBe('');
+    });
+    it('returns null when conditions array is empty', () => {
+        const status = { visible: true, isFallback: true, conditions: [] };
+        const { container } = render(_jsx(TriggerJourney, { status: status }));
+        expect(container.innerHTML).toBe('');
+    });
+    it('renders a single node for one condition', () => {
+        const status = {
+            visible: true,
+            isFallback: false,
+            conditions: [{
+                    type: 'page_url',
+                    passed: true,
+                    formatted: { label: '/pricing', instruction: 'Visit /pricing', shortLabel: '/pricing' },
+                }],
+        };
+        render(_jsx(TriggerJourney, { status: status }));
+        expect(screen.getByText('/pricing')).toBeTruthy();
+    });
+    it('renders multiple connected nodes', () => {
+        const status = {
+            visible: false,
+            isFallback: false,
+            conditions: [
+                {
+                    type: 'page_url',
+                    passed: true,
+                    formatted: { label: '/fine-arts/', instruction: 'Visit a /fine-arts/ page', shortLabel: '/fine-arts/' },
+                },
+                {
+                    type: 'event_count',
+                    passed: false,
+                    formatted: {
+                        label: 'views >= 2',
+                        instruction: 'View pages 2+ times',
+                        shortLabel: 'View 2+ times',
+                        progress: { current: 1, target: 2, operator: 'gte' },
+                    },
+                },
+            ],
+        };
+        const { container } = render(_jsx(TriggerJourney, { status: status }));
+        expect(screen.getByText('/fine-arts/')).toBeTruthy();
+        expect(screen.getByText('View 2+ times')).toBeTruthy();
+        const lines = container.querySelectorAll('[data-journey-line]');
+        expect(lines.length).toBe(1);
+    });
+    it('shows progress bar for event_count conditions', () => {
+        const status = {
+            visible: false,
+            isFallback: false,
+            conditions: [{
+                    type: 'event_count',
+                    passed: false,
+                    formatted: {
+                        label: 'clicks >= 3',
+                        instruction: 'Reach 3+ click events',
+                        shortLabel: '3+ clicks',
+                        progress: { current: 1, target: 3, operator: 'gte' },
+                    },
+                }],
+        };
+        render(_jsx(TriggerJourney, { status: status }));
+        expect(screen.getByText('1/3')).toBeTruthy();
+    });
+    it('marks passed nodes with data-passed attribute', () => {
+        const status = {
+            visible: false,
+            isFallback: false,
+            conditions: [
+                { type: 'a', passed: true, formatted: { label: 'a', instruction: 'A', shortLabel: 'A' } },
+                { type: 'b', passed: false, formatted: { label: 'b', instruction: 'B', shortLabel: 'B' } },
+            ],
+        };
+        const { container } = render(_jsx(TriggerJourney, { status: status }));
+        const nodes = container.querySelectorAll('[data-journey-node]');
+        expect(nodes.length).toBe(2);
+        expect(nodes[0].getAttribute('data-passed')).toBe('true');
+        expect(nodes[1].getAttribute('data-passed')).toBe('false');
+    });
+    it('shows "All conditions met" when all passed and multiple conditions', () => {
+        const status = {
+            visible: true,
+            isFallback: false,
+            conditions: [
+                { type: 'a', passed: true, formatted: { label: 'a', instruction: 'A', shortLabel: 'A' } },
+                { type: 'b', passed: true, formatted: { label: 'b', instruction: 'B', shortLabel: 'B' } },
+            ],
+        };
+        render(_jsx(TriggerJourney, { status: status }));
+        expect(screen.getByText('All conditions met')).toBeTruthy();
+    });
+    it('does NOT show "All conditions met" for single condition', () => {
+        const status = {
+            visible: true,
+            isFallback: false,
+            conditions: [
+                { type: 'a', passed: true, formatted: { label: 'a', instruction: 'A', shortLabel: 'A' } },
+            ],
+        };
+        render(_jsx(TriggerJourney, { status: status }));
+        expect(screen.queryByText('All conditions met')).toBeNull();
+    });
+    it('uses instruction as title attribute for tooltip', () => {
+        const status = {
+            visible: false,
+            isFallback: false,
+            conditions: [{
+                    type: 'page_url',
+                    passed: false,
+                    formatted: { label: '/p', instruction: 'Visit /pricing page', shortLabel: '/pricing' },
+                }],
+        };
+        render(_jsx(TriggerJourney, { status: status }));
+        const label = screen.getByText('/pricing');
+        expect(label.getAttribute('title')).toBe('Visit /pricing page');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { cn } from '../cn';
+describe('cn', () => {
+    it('joins multiple classes', () => {
+        expect(cn('a', 'b', 'c')).toBe('a b c');
+    });
+    it('filters out false, null, and undefined values', () => {
+        expect(cn('a', false, null, undefined, 'b')).toBe('a b');
+    });
+    it('returns empty string for no args', () => {
+        expect(cn()).toBe('');
+    });
+    it('handles a single class', () => {
+        expect(cn('only')).toBe('only');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,329 @@
+import { describe, it, expect } from 'vitest';
+import { formatConditionLabel } from '../formatConditionLabel';
+describe('formatConditionLabel', () => {
+    it('event_count: returns label with progress data', () => {
+        const result = formatConditionLabel({ type: 'event_count', key: 'click', operator: 'gte', count: 3 }, 1);
+        expect(result.label).toBe('click \u2265 3');
+        expect(result.progress).toEqual({ current: 1, target: 3, operator: 'gte' });
+        // New fields must be present
+        expect(result.instruction).toBeDefined();
+        expect(result.shortLabel).toBeDefined();
+    });
+    it('page_url: returns the url as label', () => {
+        const result = formatConditionLabel({ type: 'page_url', url: '/pricing' });
+        expect(result.label).toBe('/pricing');
+    });
+    it('viewport: returns width constraints as label', () => {
+        const result = formatConditionLabel({ type: 'viewport', maxWidth: 768 });
+        expect(result.label).toContain('w');
+        expect(result.label).toContain('768px');
+    });
+    it('viewport: returns "any viewport" when no constraints', () => {
+        const result = formatConditionLabel({ type: 'viewport' });
+        expect(result.label).toBe('any viewport');
+    });
+    it('dismissed (inverted): returns "not dismissed"', () => {
+        const result = formatConditionLabel({ type: 'dismissed', inverted: true });
+        expect(result.label).toBe('not dismissed');
+    });
+    it('cooldown_active (inverted): returns "cooldown inactive"', () => {
+        const result = formatConditionLabel({ type: 'cooldown_active', inverted: true });
+        expect(result.label).toBe('cooldown inactive');
+    });
+    it('unknown type: returns type name as label', () => {
+        const result = formatConditionLabel({ type: 'some_custom' });
+        expect(result.label).toBe('some_custom');
+    });
+});
+describe('instruction + shortLabel fields', () => {
+    describe('event_count', () => {
+        it('compound key with "page-views" returns instruction with topic and times', () => {
+            const result = formatConditionLabel({ type: 'event_count', key: 'fine-arts-page-views', operator: 'gte', count: 2 }, 0);
+            expect(result.instruction).toContain('fine arts');
+            expect(result.instruction).toContain('2+ times');
+        });
+        it('compound key shortLabel contains "2+ times"', () => {
+            const result = formatConditionLabel({ type: 'event_count', key: 'fine-arts-page-views', operator: 'gte', count: 2 }, 0);
+            expect(result.shortLabel).toContain('2+ times');
+        });
+        it('simple "click" key returns instruction mentioning click', () => {
+            const result = formatConditionLabel({ type: 'event_count', key: 'click', operator: 'gte', count: 3 }, 1);
+            expect(result.instruction.toLowerCase()).toContain('click');
+        });
+        it('click key shortLabel contains "clicks"', () => {
+            const result = formatConditionLabel({ type: 'event_count', key: 'click', operator: 'gte', count: 3 }, 1);
+            expect(result.shortLabel).toContain('click');
+        });
+        it('generic key returns instruction with "events"', () => {
+            const result = formatConditionLabel({ type: 'event_count', key: 'scroll-depth', operator: 'gte', count: 5 }, 0);
+            expect(result.instruction.toLowerCase()).toContain('event');
+        });
+    });
+    describe('page_url', () => {
+        it('url with wildcards returns instruction starting with "Visit"', () => {
+            const result = formatConditionLabel({
+                type: 'page_url',
+                url: '/fine-arts/**',
+            });
+            expect(result.instruction).toMatch(/^Visit/);
+        });
+        it('url with wildcards cleans up trailing wildcards', () => {
+            const result = formatConditionLabel({
+                type: 'page_url',
+                url: '/fine-arts/**',
+            });
+            expect(result.instruction).not.toContain('**');
+        });
+        it('simple url returns instruction starting with "Visit"', () => {
+            const result = formatConditionLabel({
+                type: 'page_url',
+                url: '/pricing',
+            });
+            expect(result.instruction).toMatch(/^Visit/);
+        });
+        it('shortLabel contains cleaned url', () => {
+            const result = formatConditionLabel({
+                type: 'page_url',
+                url: '/fine-arts/**',
+            });
+            expect(result.shortLabel).toContain('/fine-arts/');
+            expect(result.shortLabel).not.toContain('**');
+        });
+    });
+    describe('anchor_visible', () => {
+        it('instruction starts with "Scroll"', () => {
+            const result = formatConditionLabel({
+                type: 'anchor_visible',
+                anchorId: 'hero-section',
+                state: 'visible',
+            });
+            expect(result.instruction).toMatch(/^Scroll/);
+        });
+        it('instruction contains anchorId and state', () => {
+            const result = formatConditionLabel({
+                type: 'anchor_visible',
+                anchorId: 'hero-section',
+                state: 'visible',
+            });
+            expect(result.instruction).toContain('hero-section');
+            expect(result.instruction).toContain('visible');
+        });
+        it('shortLabel contains anchorId', () => {
+            const result = formatConditionLabel({
+                type: 'anchor_visible',
+                anchorId: 'hero-section',
+                state: 'visible',
+            });
+            expect(result.shortLabel).toContain('hero-section');
+        });
+    });
+    describe('event_occurred', () => {
+        it('instruction contains "event"', () => {
+            const result = formatConditionLabel({
+                type: 'event_occurred',
+                eventName: 'signup_complete',
+            });
+            expect(result.instruction.toLowerCase()).toContain('event');
+        });
+        it('instruction contains event name', () => {
+            const result = formatConditionLabel({
+                type: 'event_occurred',
+                eventName: 'signup_complete',
+            });
+            expect(result.instruction).toContain('signup_complete');
+        });
+        it('shortLabel contains event name', () => {
+            const result = formatConditionLabel({
+                type: 'event_occurred',
+                eventName: 'signup_complete',
+            });
+            expect(result.shortLabel).toContain('signup_complete');
+        });
+    });
+    describe('viewport', () => {
+        it('viewport with minWidth instruction contains pixel value', () => {
+            const result = formatConditionLabel({
+                type: 'viewport',
+                minWidth: 768,
+            });
+            expect(result.instruction).toContain('768px');
+        });
+        it('viewport instruction starts with "Use a viewport"', () => {
+            const result = formatConditionLabel({
+                type: 'viewport',
+                minWidth: 768,
+            });
+            expect(result.instruction).toMatch(/^Use a viewport/);
+        });
+        it('viewport with no constraints shortLabel is "Any size"', () => {
+            const result = formatConditionLabel({ type: 'viewport' });
+            expect(result.shortLabel).toBe('Any size');
+        });
+    });
+    describe('session_metric', () => {
+        it('instruction contains key and threshold', () => {
+            const result = formatConditionLabel({
+                type: 'session_metric',
+                key: 'time_on_page',
+                operator: 'gte',
+                threshold: 30,
+            });
+            expect(result.instruction).toContain('time_on_page');
+            expect(result.instruction).toContain('30');
+        });
+        it('shortLabel contains key and threshold', () => {
+            const result = formatConditionLabel({
+                type: 'session_metric',
+                key: 'time_on_page',
+                operator: 'gte',
+                threshold: 30,
+            });
+            expect(result.shortLabel).toContain('time_on_page');
+            expect(result.shortLabel).toContain('30');
+        });
+    });
+    describe('dismissed', () => {
+        it('inverted instruction contains "Do not dismiss" or "not dismiss"', () => {
+            const result = formatConditionLabel({
+                type: 'dismissed',
+                inverted: true,
+                key: 'promo-banner',
+            });
+            expect(result.instruction.toLowerCase()).toContain('not dismiss');
+        });
+        it('non-inverted instruction contains "Dismiss"', () => {
+            const result = formatConditionLabel({
+                type: 'dismissed',
+                inverted: false,
+                key: 'promo-banner',
+            });
+            expect(result.instruction).toContain('Dismiss');
+        });
+        it('inverted shortLabel contains "Not dismissed"', () => {
+            const result = formatConditionLabel({
+                type: 'dismissed',
+                inverted: true,
+                key: 'promo-banner',
+            });
+            expect(result.shortLabel).toBe('Not dismissed');
+        });
+        it('non-inverted shortLabel contains "Dismissed"', () => {
+            const result = formatConditionLabel({
+                type: 'dismissed',
+                inverted: false,
+                key: 'promo-banner',
+            });
+            expect(result.shortLabel).toBe('Dismissed');
+        });
+    });
+    describe('cooldown_active', () => {
+        it('inverted instruction contains "Wait for cooldown"', () => {
+            const result = formatConditionLabel({
+                type: 'cooldown_active',
+                inverted: true,
+            });
+            expect(result.instruction).toContain('Wait for cooldown');
+        });
+        it('non-inverted instruction contains "Cooldown is active"', () => {
+            const result = formatConditionLabel({
+                type: 'cooldown_active',
+                inverted: false,
+            });
+            expect(result.instruction).toContain('Cooldown is active');
+        });
+        it('inverted shortLabel is "Cooldown done"', () => {
+            const result = formatConditionLabel({
+                type: 'cooldown_active',
+                inverted: true,
+            });
+            expect(result.shortLabel).toBe('Cooldown done');
+        });
+        it('non-inverted shortLabel is "Cooldown active"', () => {
+            const result = formatConditionLabel({
+                type: 'cooldown_active',
+                inverted: false,
+            });
+            expect(result.shortLabel).toBe('Cooldown active');
+        });
+    });
+    describe('frequency_limit', () => {
+        it('inverted instruction contains "fewer than"', () => {
+            const result = formatConditionLabel({
+                type: 'frequency_limit',
+                inverted: true,
+                limit: 5,
+            });
+            expect(result.instruction).toContain('fewer than');
+        });
+        it('non-inverted instruction contains "Shown"', () => {
+            const result = formatConditionLabel({
+                type: 'frequency_limit',
+                inverted: false,
+                limit: 5,
+            });
+            expect(result.instruction).toContain('Shown');
+        });
+        it('inverted shortLabel is "< N views"', () => {
+            const result = formatConditionLabel({
+                type: 'frequency_limit',
+                inverted: true,
+                limit: 5,
+            });
+            expect(result.shortLabel).toBe('< 5 views');
+        });
+        it('non-inverted shortLabel is "N+ views"', () => {
+            const result = formatConditionLabel({
+                type: 'frequency_limit',
+                inverted: false,
+                limit: 5,
+            });
+            expect(result.shortLabel).toBe('5+ views');
+        });
+    });
+    describe('route', () => {
+        it('instruction contains "Navigate to"', () => {
+            const result = formatConditionLabel({
+                type: 'route',
+                routeId: 'checkout',
+            });
+            expect(result.instruction).toContain('Navigate to');
+            expect(result.instruction).toContain('checkout');
+        });
+        it('shortLabel is routeId', () => {
+            const result = formatConditionLabel({
+                type: 'route',
+                routeId: 'checkout',
+            });
+            expect(result.shortLabel).toBe('checkout');
+        });
+    });
+    describe('state_equals', () => {
+        it('instruction contains key and value', () => {
+            const result = formatConditionLabel({
+                type: 'state_equals',
+                key: 'theme',
+                value: 'dark',
+            });
+            expect(result.instruction).toContain('theme');
+            expect(result.instruction).toContain('dark');
+        });
+        it('shortLabel is key', () => {
+            const result = formatConditionLabel({
+                type: 'state_equals',
+                key: 'theme',
+                value: 'dark',
+            });
+            expect(result.shortLabel).toBe('theme');
+        });
+    });
+    describe('unknown type', () => {
+        it('instruction equals the type string', () => {
+            const result = formatConditionLabel({ type: 'some_custom' });
+            expect(result.instruction).toBe('some_custom');
+        });
+        it('shortLabel equals the type string', () => {
+            const result = formatConditionLabel({ type: 'some_custom' });
+            expect(result.shortLabel).toBe('some_custom');
+        });
+    });
+});

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

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

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

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