@syntrologie/adapt-nav 2.5.1 → 2.6.0-canary.2

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

@@ -1,1015 +0,0 @@
-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);
-        });
-    });
-});