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

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

@@ -1,329 +0,0 @@
-import { describe, expect, it } 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__/selectorGenerator.test.d.ts

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

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

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

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

@@ -1,257 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-// Shim CSS.escape for jsdom (not available by default)
-if (typeof CSS === 'undefined') {
-    globalThis.CSS = { escape: (str) => str.replace(/([^\w-])/g, '\\$1') };
-}
-else if (!CSS.escape) {
-    CSS.escape = (str) => str.replace(/([^\w-])/g, '\\$1');
-}
-import { generateSelector, getElementDescription, validateSelector, } from '../utils/selectorGenerator';
-// =============================================================================
-// Mock css-selector-generator
-// =============================================================================
-vi.mock('css-selector-generator', () => ({
-    getCssSelector: vi.fn(),
-}));
-import { getCssSelector } from 'css-selector-generator';
-const mockGetCssSelector = vi.mocked(getCssSelector);
-// =============================================================================
-// HELPERS
-// =============================================================================
-function createElement(tag, attrs = {}) {
-    const el = document.createElement(tag);
-    for (const [key, value] of Object.entries(attrs)) {
-        if (key === 'textContent') {
-            el.textContent = value;
-        }
-        else if (key === 'className') {
-            el.className = value;
-        }
-        else {
-            el.setAttribute(key, value);
-        }
-    }
-    document.body.appendChild(el);
-    return el;
-}
-// =============================================================================
-// generateSelector
-// =============================================================================
-describe('generateSelector', () => {
-    afterEach(() => {
-        vi.clearAllMocks();
-        document.body.innerHTML = '';
-    });
-    it('calls getCssSelector with element and default options', () => {
-        const el = createElement('div');
-        mockGetCssSelector.mockReturnValue('div');
-        generateSelector(el);
-        expect(mockGetCssSelector).toHaveBeenCalledWith(el, expect.objectContaining({
-            includeTag: true,
-            maxCombinations: 100,
-        }));
-    });
-    it('returns the selector from getCssSelector', () => {
-        const el = createElement('div', { id: 'my-id' });
-        mockGetCssSelector.mockReturnValue('#my-id');
-        const result = generateSelector(el);
-        expect(result).toBe('#my-id');
-    });
-    it('passes custom options through', () => {
-        const el = createElement('div');
-        mockGetCssSelector.mockReturnValue('div');
-        generateSelector(el, { includeTag: false, maxCombinations: 50 });
-        expect(mockGetCssSelector).toHaveBeenCalledWith(el, expect.objectContaining({
-            includeTag: false,
-            maxCombinations: 50,
-        }));
-    });
-    it('includes attribute selectors when preferTestIds is true (default)', () => {
-        const el = createElement('div');
-        mockGetCssSelector.mockReturnValue('div');
-        generateSelector(el);
-        const call = mockGetCssSelector.mock.calls[0];
-        const options = call[1];
-        expect(options.selectors).toContain('attribute');
-    });
-    it('excludes attribute selectors when preferTestIds is false', () => {
-        const el = createElement('div');
-        mockGetCssSelector.mockReturnValue('div');
-        generateSelector(el, { preferTestIds: false });
-        const call = mockGetCssSelector.mock.calls[0];
-        const options = call[1];
-        expect(options.selectors).not.toContain('attribute');
-    });
-    it('includes blacklist patterns for dynamic classes', () => {
-        const el = createElement('div');
-        mockGetCssSelector.mockReturnValue('div');
-        generateSelector(el);
-        const call = mockGetCssSelector.mock.calls[0];
-        const options = call[1];
-        expect(options.blacklist).toBeDefined();
-        expect(Array.isArray(options.blacklist)).toBe(true);
-        expect(options.blacklist.length).toBeGreaterThan(0);
-    });
-    it('includes whitelist for stable attributes', () => {
-        const el = createElement('div');
-        mockGetCssSelector.mockReturnValue('div');
-        generateSelector(el);
-        const call = mockGetCssSelector.mock.calls[0];
-        const options = call[1];
-        expect(options.whitelist).toBeDefined();
-        expect(Array.isArray(options.whitelist)).toBe(true);
-    });
-    it('falls back to generateFallbackSelector when getCssSelector throws', () => {
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        const parent = document.createElement('div');
-        parent.id = 'parent';
-        document.body.appendChild(parent);
-        const child = document.createElement('span');
-        parent.appendChild(child);
-        mockGetCssSelector.mockImplementation(() => {
-            throw new Error('Failed');
-        });
-        const result = generateSelector(child);
-        // Fallback should produce a path-based selector
-        expect(result).toContain('#parent');
-        expect(result).toContain('span');
-        expect(warnSpy).toHaveBeenCalled();
-        document.body.removeChild(parent);
-    });
-    describe('fallback selector generation', () => {
-        it('uses ID when element has an ID', () => {
-            const el = document.createElement('div');
-            el.id = 'unique-element';
-            document.body.appendChild(el);
-            mockGetCssSelector.mockImplementation(() => {
-                throw new Error('Failed');
-            });
-            vi.spyOn(console, 'warn').mockImplementation(() => { });
-            const result = generateSelector(el);
-            expect(result).toContain('#unique-element');
-            document.body.removeChild(el);
-        });
-        it('uses nth-child for elements without ID', () => {
-            const parent = document.createElement('div');
-            document.body.appendChild(parent);
-            const child1 = document.createElement('p');
-            const child2 = document.createElement('p');
-            parent.appendChild(child1);
-            parent.appendChild(child2);
-            mockGetCssSelector.mockImplementation(() => {
-                throw new Error('Failed');
-            });
-            vi.spyOn(console, 'warn').mockImplementation(() => { });
-            const result = generateSelector(child2);
-            expect(result).toContain('nth-child');
-            document.body.removeChild(parent);
-        });
-        it('stops at element with ID (shortest unique path)', () => {
-            const grandparent = document.createElement('div');
-            grandparent.id = 'root';
-            document.body.appendChild(grandparent);
-            const parent = document.createElement('div');
-            grandparent.appendChild(parent);
-            const child = document.createElement('span');
-            parent.appendChild(child);
-            mockGetCssSelector.mockImplementation(() => {
-                throw new Error('Failed');
-            });
-            vi.spyOn(console, 'warn').mockImplementation(() => { });
-            const result = generateSelector(child);
-            // Should start with #root
-            expect(result.startsWith('#root')).toBe(true);
-            document.body.removeChild(grandparent);
-        });
-    });
-});
-// =============================================================================
-// validateSelector
-// =============================================================================
-describe('validateSelector', () => {
-    afterEach(() => {
-        document.body.innerHTML = '';
-    });
-    it('returns true when selector matches the expected element', () => {
-        const el = createElement('div', { id: 'target' });
-        expect(validateSelector('#target', el)).toBe(true);
-    });
-    it('returns false when selector matches a different element', () => {
-        const el1 = createElement('div', { id: 'first' });
-        createElement('div', { id: 'second' });
-        expect(validateSelector('#second', el1)).toBe(false);
-    });
-    it('returns false when selector matches nothing', () => {
-        const el = createElement('div');
-        expect(validateSelector('#nonexistent', el)).toBe(false);
-    });
-    it('returns false for invalid selector syntax', () => {
-        const el = createElement('div');
-        expect(validateSelector('[[[invalid', el)).toBe(false);
-    });
-});
-// =============================================================================
-// getElementDescription
-// =============================================================================
-describe('getElementDescription', () => {
-    afterEach(() => {
-        document.body.innerHTML = '';
-    });
-    it('includes tag name', () => {
-        const el = createElement('button');
-        expect(getElementDescription(el)).toContain('button');
-    });
-    it('includes ID when present', () => {
-        const el = createElement('div', { id: 'my-btn' });
-        expect(getElementDescription(el)).toContain('#my-btn');
-    });
-    it('includes static class names', () => {
-        const el = createElement('div', { className: 'header main-content' });
-        const desc = getElementDescription(el);
-        expect(desc).toContain('.header');
-        expect(desc).toContain('.main-content');
-    });
-    it('excludes dynamic class names', () => {
-        const el = createElement('div', { className: 'css-1abc23 my-class' });
-        const desc = getElementDescription(el);
-        // Dynamic class css-1abc23 should be filtered out
-        expect(desc).not.toContain('css-1abc23');
-        expect(desc).toContain('my-class');
-    });
-    it('includes text content preview (truncated at 30 chars)', () => {
-        const el = createElement('p', {
-            textContent: 'This is a very long text that should be truncated',
-        });
-        const desc = getElementDescription(el);
-        expect(desc).toContain('"');
-        expect(desc).toContain('...');
-    });
-    it('includes full text for short content', () => {
-        const el = createElement('span', { textContent: 'Hello' });
-        const desc = getElementDescription(el);
-        expect(desc).toContain('"Hello"');
-        expect(desc).not.toContain('...');
-    });
-    it('handles elements with no text content', () => {
-        const el = createElement('img');
-        const desc = getElementDescription(el);
-        expect(desc).toBe('img');
-    });
-    it('limits class names to 2', () => {
-        const el = createElement('div', { className: 'cls-a cls-b cls-c cls-d' });
-        const desc = getElementDescription(el);
-        // Should include at most 2 classes
-        expect(desc).toContain('.cls-a');
-        expect(desc).toContain('.cls-b');
-        expect(desc).not.toContain('.cls-c');
-    });
-    it('handles SVGElement className (not a string)', () => {
-        const svgNS = 'http://www.w3.org/2000/svg';
-        const svg = document.createElementNS(svgNS, 'svg');
-        document.body.appendChild(svg);
-        // SVGElement.className is an SVGAnimatedString, not a string
-        const desc = getElementDescription(svg);
-        expect(desc).toContain('svg');
-        document.body.removeChild(svg);
-    });
-});

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

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

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

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