@syntrologie/adapt-content 2.4.0 → 2.5.1

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

@@ -0,0 +1,257 @@
+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__/useTriggerWhenStatus.test.d.ts

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

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

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