@syntrologie/adapt-content 2.4.0 → 2.5.1

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

@@ -0,0 +1,1015 @@
+import { act, renderHook } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useTriggerWhenStatus } from '../hooks/useTriggerWhenStatus';
+function createMockRuntime(overrides = {}) {
+    return {
+        context: {
+            get: () => ({
+                page: { url: '/products', routeId: 'products' },
+                viewport: { width: 1024, height: 768 },
+                anchors: [],
+            }),
+        },
+        accumulator: {
+            getCount: () => 0,
+            subscribe: () => () => { },
+        },
+        events: {
+            hasRecentEvent: () => false,
+        },
+        state: {
+            isDismissed: () => false,
+            isCooldownActive: () => false,
+            getFrequencyCount: () => 0,
+            getSessionMetric: () => 0,
+        },
+        ...overrides,
+    };
+}
+function setRuntime(runtime) {
+    if (runtime) {
+        window.SynOS = { handle: { runtime } };
+    }
+    else {
+        delete window.SynOS;
+    }
+}
+// =============================================================================
+// TESTS
+// =============================================================================
+describe('useTriggerWhenStatus', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+        setRuntime(null);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        setRuntime(null);
+    });
+    // ===========================================================================
+    // Basic behavior
+    // ===========================================================================
+    it('returns empty map when no runtime is available', () => {
+        setRuntime(null);
+        const { result } = renderHook(() => useTriggerWhenStatus([]));
+        expect(result.current.size).toBe(0);
+    });
+    it('returns null status for items without triggerWhen', () => {
+        setRuntime(createMockRuntime());
+        const items = [{ id: 'item-1' }];
+        const { result } = renderHook(() => useTriggerWhenStatus(items));
+        expect(result.current.get('item-1')).toBeNull();
+    });
+    it('returns fallback status for non-rules type triggerWhen', () => {
+        setRuntime(createMockRuntime());
+        const items = [
+            {
+                id: 'item-1',
+                triggerWhen: { type: 'always', default: true },
+            },
+        ];
+        const { result } = renderHook(() => useTriggerWhenStatus(items));
+        const status = result.current.get('item-1');
+        expect(status?.visible).toBe(true);
+        expect(status?.isFallback).toBe(true);
+        expect(status?.conditions).toEqual([]);
+    });
+    it('returns fallback status for rules type with no rules', () => {
+        setRuntime(createMockRuntime());
+        const items = [
+            {
+                id: 'item-1',
+                triggerWhen: { type: 'rules', rules: [], default: false },
+            },
+        ];
+        const { result } = renderHook(() => useTriggerWhenStatus(items));
+        const status = result.current.get('item-1');
+        expect(status?.visible).toBe(false);
+        expect(status?.isFallback).toBe(true);
+    });
+    // ===========================================================================
+    // event_count condition
+    // ===========================================================================
+    describe('event_count condition', () => {
+        it('passes when count >= target (gte)', () => {
+            setRuntime(createMockRuntime({
+                accumulator: {
+                    getCount: (key) => (key === 'page-views' ? 5 : 0),
+                    subscribe: () => () => { },
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'event_count', key: 'page-views', operator: 'gte', count: 3 }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            const status = result.current.get('item-1');
+            expect(status?.visible).toBe(true);
+            expect(status?.isFallback).toBe(false);
+            expect(status?.conditions[0].passed).toBe(true);
+        });
+        it('fails when count < target (gte)', () => {
+            setRuntime(createMockRuntime({
+                accumulator: {
+                    getCount: () => 2,
+                    subscribe: () => () => { },
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'event_count', key: 'clicks', operator: 'gte', count: 5 }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            const status = result.current.get('item-1');
+            expect(status?.visible).toBe(false);
+            expect(status?.isFallback).toBe(true);
+        });
+        it.each([
+            { operator: 'lte', count: 5, actual: 3, expected: true },
+            { operator: 'lte', count: 3, actual: 5, expected: false },
+            { operator: 'eq', count: 3, actual: 3, expected: true },
+            { operator: 'eq', count: 3, actual: 4, expected: false },
+            { operator: 'gt', count: 3, actual: 4, expected: true },
+            { operator: 'gt', count: 3, actual: 3, expected: false },
+            { operator: 'lt', count: 3, actual: 2, expected: true },
+            { operator: 'lt', count: 3, actual: 3, expected: false },
+        ])('event_count $operator: actual=$actual vs target=$count => $expected', ({ operator, count, actual, expected, }) => {
+            setRuntime(createMockRuntime({
+                accumulator: {
+                    getCount: () => actual,
+                    subscribe: () => () => { },
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'event_count', key: 'events', operator, count }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(expected);
+        });
+        it('skips event_count when accumulator is missing', () => {
+            setRuntime(createMockRuntime({
+                accumulator: undefined,
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'event_count', key: 'clicks', operator: 'gte', count: 1 }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+    });
+    // ===========================================================================
+    // page_url condition
+    // ===========================================================================
+    describe('page_url condition', () => {
+        it('passes for exact URL match', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/products' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'page_url', url: '/products' }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('passes for single-star wildcard URL match (single segment)', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/products/shoes' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'page_url', url: '/products/*' }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('single-star wildcard does not match multi-segment paths', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/products/shoes/running' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'page_url', url: '/products/*' }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            // Single * only matches one path segment
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+        it('fails for non-matching URL', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/about' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'page_url', url: '/products' }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+    });
+    // ===========================================================================
+    // route condition
+    // ===========================================================================
+    describe('route condition', () => {
+        it('passes when routeId matches', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/products', routeId: 'products' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'route', routeId: 'products' }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('fails when routeId does not match', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/about', routeId: 'about' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'route', routeId: 'home' }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+    });
+    // ===========================================================================
+    // anchor_visible condition
+    // ===========================================================================
+    describe('anchor_visible condition', () => {
+        it('passes for visible anchor', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 1024, height: 768 },
+                        anchors: [{ anchorId: 'hero', visible: true, present: true }],
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'anchor_visible', anchorId: 'hero', state: 'visible' }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('passes for present anchor', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 1024, height: 768 },
+                        anchors: [{ anchorId: 'sidebar', visible: false, present: true }],
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'anchor_visible', anchorId: 'sidebar', state: 'present' }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('passes for absent anchor', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 1024, height: 768 },
+                        anchors: [],
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [
+                                    { type: 'anchor_visible', anchorId: 'deleted-section', state: 'absent' },
+                                ],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+    });
+    // ===========================================================================
+    // event_occurred condition
+    // ===========================================================================
+    describe('event_occurred condition', () => {
+        it('passes when recent event exists', () => {
+            setRuntime(createMockRuntime({
+                events: { hasRecentEvent: (name) => name === 'click_cta' },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'event_occurred', eventName: 'click_cta', withinMs: 5000 }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('falls back to false when events service is missing', () => {
+            setRuntime(createMockRuntime({
+                events: undefined,
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'event_occurred', eventName: 'click_cta' }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+    });
+    // ===========================================================================
+    // viewport condition
+    // ===========================================================================
+    describe('viewport condition', () => {
+        it('passes when viewport matches all constraints', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [
+                                    {
+                                        type: 'viewport',
+                                        minWidth: 800,
+                                        maxWidth: 1200,
+                                        minHeight: 600,
+                                        maxHeight: 900,
+                                    },
+                                ],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('fails when width is below minWidth', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 500, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'viewport', minWidth: 800 }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+        it('fails when width exceeds maxWidth', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 2000, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'viewport', maxWidth: 1200 }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+        it('fails when height is below minHeight', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 1024, height: 300 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'viewport', minHeight: 600 }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+        it('fails when height exceeds maxHeight', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/' },
+                        viewport: { width: 1024, height: 1500 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'viewport', maxHeight: 900 }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+        });
+    });
+    // ===========================================================================
+    // session_metric condition
+    // ===========================================================================
+    describe('session_metric condition', () => {
+        it.each([
+            { operator: 'gte', threshold: 3, actual: 5, expected: true },
+            { operator: 'gte', threshold: 5, actual: 3, expected: false },
+            { operator: 'lte', threshold: 5, actual: 3, expected: true },
+            { operator: 'eq', threshold: 3, actual: 3, expected: true },
+            { operator: 'gt', threshold: 3, actual: 4, expected: true },
+            { operator: 'lt', threshold: 3, actual: 2, expected: true },
+        ])('session_metric $operator: $actual vs $threshold => $expected', ({ operator, threshold, actual, expected, }) => {
+            setRuntime(createMockRuntime({
+                state: {
+                    isDismissed: () => false,
+                    isCooldownActive: () => false,
+                    getFrequencyCount: () => 0,
+                    getSessionMetric: (key) => (key === 'engagement' ? actual : 0),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'session_metric', key: 'engagement', operator, threshold }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(expected);
+        });
+    });
+    // ===========================================================================
+    // dismissed condition
+    // ===========================================================================
+    describe('dismissed condition', () => {
+        it('passes when item is dismissed', () => {
+            setRuntime(createMockRuntime({
+                state: {
+                    isDismissed: (key) => key === 'tooltip-1',
+                    isCooldownActive: () => false,
+                    getFrequencyCount: () => 0,
+                    getSessionMetric: () => 0,
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'dismissed', key: 'tooltip-1' }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('passes inverted dismissed (not dismissed)', () => {
+            setRuntime(createMockRuntime({
+                state: {
+                    isDismissed: () => false,
+                    isCooldownActive: () => false,
+                    getFrequencyCount: () => 0,
+                    getSessionMetric: () => 0,
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'dismissed', key: 'tooltip-1', inverted: true }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+    });
+    // ===========================================================================
+    // cooldown_active condition
+    // ===========================================================================
+    describe('cooldown_active condition', () => {
+        it('passes when cooldown is active', () => {
+            setRuntime(createMockRuntime({
+                state: {
+                    isDismissed: () => false,
+                    isCooldownActive: () => true,
+                    getFrequencyCount: () => 0,
+                    getSessionMetric: () => 0,
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'cooldown_active', key: 'tip-1' }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('passes inverted cooldown (cooldown not active)', () => {
+            setRuntime(createMockRuntime({
+                state: {
+                    isDismissed: () => false,
+                    isCooldownActive: () => false,
+                    getFrequencyCount: () => 0,
+                    getSessionMetric: () => 0,
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'cooldown_active', key: 'tip-1', inverted: true }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+    });
+    // ===========================================================================
+    // frequency_limit condition
+    // ===========================================================================
+    describe('frequency_limit condition', () => {
+        it('passes when frequency count >= limit', () => {
+            setRuntime(createMockRuntime({
+                state: {
+                    isDismissed: () => false,
+                    isCooldownActive: () => false,
+                    getFrequencyCount: () => 5,
+                    getSessionMetric: () => 0,
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'frequency_limit', key: 'tip-1', limit: 3 }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('passes inverted frequency limit (below limit)', () => {
+            setRuntime(createMockRuntime({
+                state: {
+                    isDismissed: () => false,
+                    isCooldownActive: () => false,
+                    getFrequencyCount: () => 1,
+                    getSessionMetric: () => 0,
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'frequency_limit', key: 'tip-1', limit: 3, inverted: true }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+    });
+    // ===========================================================================
+    // Multi-condition rules
+    // ===========================================================================
+    describe('multi-condition rules', () => {
+        it('requires ALL conditions to pass for a rule to match', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/products', routeId: 'products' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+                accumulator: {
+                    getCount: () => 5,
+                    subscribe: () => () => { },
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [
+                                    { type: 'page_url', url: '/products' },
+                                    { type: 'event_count', key: 'views', operator: 'gte', count: 3 },
+                                ],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.visible).toBe(true);
+        });
+        it('falls through to next rule when first rule fails', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/about', routeId: 'about' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'page_url', url: '/products' }],
+                                value: true,
+                            },
+                            {
+                                conditions: [{ type: 'page_url', url: '/about' }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            expect(result.current.get('item-1')?.visible).toBe(true);
+        });
+        it('falls to default when no rules match', () => {
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: '/contact' },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'page_url', url: '/products' }], value: true }],
+                        default: true,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            const status = result.current.get('item-1');
+            expect(status?.visible).toBe(true);
+            expect(status?.isFallback).toBe(true);
+        });
+    });
+    // ===========================================================================
+    // Reactive updates
+    // ===========================================================================
+    describe('reactive updates', () => {
+        it('subscribes to accumulator and re-evaluates on changes', () => {
+            let subscribeCb = null;
+            let currentCount = 0;
+            setRuntime(createMockRuntime({
+                accumulator: {
+                    getCount: () => currentCount,
+                    subscribe: (cb) => {
+                        subscribeCb = cb;
+                        return () => {
+                            subscribeCb = null;
+                        };
+                    },
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [
+                            {
+                                conditions: [{ type: 'event_count', key: 'clicks', operator: 'gte', count: 3 }],
+                                value: true,
+                            },
+                        ],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            // Initially: count=0, should fail
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(false);
+            // Update count and trigger subscription
+            currentCount = 5;
+            act(() => {
+                subscribeCb?.();
+            });
+            expect(result.current.get('item-1')?.conditions[0].passed).toBe(true);
+        });
+        it('re-evaluates on polling interval', () => {
+            let currentUrl = '/home';
+            setRuntime(createMockRuntime({
+                context: {
+                    get: () => ({
+                        page: { url: currentUrl },
+                        viewport: { width: 1024, height: 768 },
+                    }),
+                },
+            }));
+            const items = [
+                {
+                    id: 'item-1',
+                    triggerWhen: {
+                        type: 'rules',
+                        rules: [{ conditions: [{ type: 'page_url', url: '/products' }], value: true }],
+                        default: false,
+                    },
+                },
+            ];
+            const { result } = renderHook(() => useTriggerWhenStatus(items));
+            // Initially: URL is /home, should fail
+            expect(result.current.get('item-1')?.visible).toBe(false);
+            // Change URL and advance timer
+            currentUrl = '/products';
+            act(() => {
+                vi.advanceTimersByTime(2000);
+            });
+            expect(result.current.get('item-1')?.visible).toBe(true);
+        });
+        it('cleans up subscription and interval on unmount', () => {
+            let unsubCalled = false;
+            setRuntime(createMockRuntime({
+                accumulator: {
+                    getCount: () => 0,
+                    subscribe: () => () => {
+                        unsubCalled = true;
+                    },
+                },
+            }));
+            const { unmount } = renderHook(() => useTriggerWhenStatus([]));
+            unmount();
+            expect(unsubCalled).toBe(true);
+        });
+    });
+});