angular-debug-recorder 1.0.0

package/esm2022/lib/services/ai-generator.service.mjs

@@ -0,0 +1,61 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class AiGeneratorService {
+    constructor(http) {
+        this.http = http;
+        this._webhookUrl = signal(localStorage.getItem('debugRecorder_webhookUrl') ?? '');
+        this._isGenerating = signal(false);
+        this._error = signal(null);
+        this._lastTest = signal(null);
+        this.webhookUrl = this._webhookUrl.asReadonly();
+        this.isGenerating = this._isGenerating.asReadonly();
+        this.error = this._error.asReadonly();
+        this.lastTest = this._lastTest.asReadonly();
+    }
+    setWebhookUrl(url) {
+        this._webhookUrl.set(url);
+        localStorage.setItem('debugRecorder_webhookUrl', url);
+    }
+    async generateCypressTest(session) {
+        const url = this._webhookUrl();
+        if (!url)
+            throw new Error('Keine Webhook-URL konfiguriert');
+        this._isGenerating.set(true);
+        this._error.set(null);
+        try {
+            const code = await this.postSession(url, session);
+            const test = {
+                code,
+                generatedAt: Date.now(),
+                model: url,
+                sessionId: session.id,
+            };
+            this._lastTest.set(test);
+            return test;
+        }
+        catch (err) {
+            const msg = err?.error?.message || err?.message || 'Fehler beim Senden';
+            this._error.set(msg);
+            throw err;
+        }
+        finally {
+            this._isGenerating.set(false);
+        }
+    }
+    postSession(url, session) {
+        return new Promise((resolve, reject) => {
+            this.http.post(url, session, { responseType: 'text' }).subscribe({
+                next: (res) => resolve(res),
+                error: reject,
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AiGeneratorService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AiGeneratorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AiGeneratorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/recorder.service.mjs

@@ -0,0 +1,354 @@
+import { Injectable, signal, computed } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RecorderService {
+    constructor(zone) {
+        this.zone = zone;
+        this._isRecording = signal(false);
+        this._currentSession = signal(null);
+        this._sessions = signal([]);
+        this._isPaused = signal(false);
+        this.isRecording = computed(() => this._isRecording());
+        this.isPaused = computed(() => this._isPaused());
+        this.currentSession = computed(() => this._currentSession());
+        this.sessions = computed(() => this._sessions());
+        this.actionCount = computed(() => this._currentSession()?.actions.length ?? 0);
+        this.listeners = [];
+        this.lastScrollTime = 0;
+    }
+    startRecording(name, description) {
+        const session = {
+            id: this.generateId(),
+            name: name || `Session ${new Date().toLocaleTimeString()}`,
+            description,
+            startTime: Date.now(),
+            startUrl: window.location.href,
+            actions: [],
+            tags: [],
+        };
+        this._currentSession.set(session);
+        this._isRecording.set(true);
+        this._isPaused.set(false);
+        this.attachListeners();
+        this.recordNavigation('navigation', window.location.href);
+    }
+    stopRecording() {
+        const session = this._currentSession();
+        if (!session)
+            return null;
+        const completed = { ...session, endTime: Date.now() };
+        this._sessions.update(s => [...s, completed]);
+        this._currentSession.set(null);
+        this._isRecording.set(false);
+        this._isPaused.set(false);
+        this.detachListeners();
+        return completed;
+    }
+    pauseRecording() {
+        if (this._isRecording()) {
+            this._isPaused.set(!this._isPaused());
+        }
+    }
+    clearCurrentSession() {
+        this._currentSession.update(s => s ? { ...s, actions: [] } : null);
+    }
+    removeAction(actionId) {
+        this._currentSession.update(s => s ? { ...s, actions: s.actions.filter(a => a.id !== actionId) } : null);
+    }
+    addNote(actionId, note) {
+        this._currentSession.update(s => s ? {
+            ...s,
+            actions: s.actions.map(a => a.id === actionId ? { ...a, note } : a)
+        } : null);
+    }
+    deleteSession(sessionId) {
+        this._sessions.update(s => s.filter(x => x.id !== sessionId));
+    }
+    loadSession(session) {
+        this._currentSession.set(session);
+    }
+    // ─── Event Listeners ──────────────────────────────────────────────────────
+    attachListeners() {
+        const opts = { capture: true, passive: true };
+        const onClick = (e) => this.zone.run(() => this.handleClick(e));
+        const onDblClick = (e) => this.zone.run(() => this.handleDblClick(e));
+        const onInput = (e) => this.zone.run(() => this.handleInput(e));
+        const onChange = (e) => this.zone.run(() => this.handleChange(e));
+        const onSubmit = (e) => this.zone.run(() => this.handleSubmit(e));
+        const onKeydown = (e) => this.zone.run(() => this.handleKeydown(e));
+        const onScroll = (e) => this.zone.run(() => this.handleScroll(e));
+        document.addEventListener('click', onClick, opts);
+        document.addEventListener('dblclick', onDblClick, opts);
+        document.addEventListener('input', onInput, opts);
+        document.addEventListener('change', onChange, opts);
+        document.addEventListener('submit', onSubmit, opts);
+        document.addEventListener('keydown', onKeydown, opts);
+        document.addEventListener('scroll', onScroll, { capture: true, passive: true });
+        this.listeners = [
+            { type: 'click', fn: onClick },
+            { type: 'dblclick', fn: onDblClick },
+            { type: 'input', fn: onInput },
+            { type: 'change', fn: onChange },
+            { type: 'submit', fn: onSubmit },
+            { type: 'keydown', fn: onKeydown },
+            { type: 'scroll', fn: onScroll },
+        ];
+    }
+    detachListeners() {
+        this.listeners.forEach(({ type, fn }) => document.removeEventListener(type, fn, true));
+        this.listeners = [];
+        this.mutationObserver?.disconnect();
+    }
+    // ─── Handlers ─────────────────────────────────────────────────────────────
+    handleClick(e) {
+        if (!this.shouldRecord(e.target))
+            return;
+        const el = e.target;
+        const info = this.getElementInfo(el);
+        const selector = this.buildSelector(el);
+        this.addAction({
+            type: 'click',
+            selector,
+            selectorStrategy: this.getSelectorStrategy(el),
+            element: info,
+            description: `Click on ${this.describeElement(info)}`,
+        });
+    }
+    handleDblClick(e) {
+        if (!this.shouldRecord(e.target))
+            return;
+        const el = e.target;
+        const info = this.getElementInfo(el);
+        const selector = this.buildSelector(el);
+        this.addAction({
+            type: 'dblclick',
+            selector,
+            selectorStrategy: this.getSelectorStrategy(el),
+            element: info,
+            description: `Double-click on ${this.describeElement(info)}`,
+        });
+    }
+    handleInput(e) {
+        if (!this.shouldRecord(e.target))
+            return;
+        const el = e.target;
+        if (['checkbox', 'radio'].includes(el.type))
+            return; // handled by change
+        const info = this.getElementInfo(el);
+        const selector = this.buildSelector(el);
+        this.addAction({
+            type: 'input',
+            selector,
+            selectorStrategy: this.getSelectorStrategy(el),
+            element: info,
+            value: el.value,
+            description: `Type "${el.value}" in ${this.describeElement(info)}`,
+        });
+    }
+    handleChange(e) {
+        if (!this.shouldRecord(e.target))
+            return;
+        const el = e.target;
+        const info = this.getElementInfo(el);
+        const selector = this.buildSelector(el);
+        if (el.tagName === 'SELECT') {
+            this.addAction({
+                type: 'select',
+                selector,
+                selectorStrategy: this.getSelectorStrategy(el),
+                element: info,
+                value: el.value,
+                description: `Select "${el.value}" in ${this.describeElement(info)}`,
+            });
+        }
+        else if (el.type === 'checkbox') {
+            this.addAction({
+                type: 'click',
+                selector,
+                selectorStrategy: this.getSelectorStrategy(el),
+                element: info,
+                value: String(el.checked),
+                description: `${el.checked ? 'Check' : 'Uncheck'} ${this.describeElement(info)}`,
+            });
+        }
+    }
+    handleSubmit(e) {
+        if (!this.shouldRecord(e.target))
+            return;
+        const form = e.target;
+        const info = this.getElementInfo(form);
+        const selector = this.buildSelector(form);
+        this.addAction({
+            type: 'submit',
+            selector,
+            selectorStrategy: this.getSelectorStrategy(form),
+            element: info,
+            description: `Submit form ${info.id ? '#' + info.id : info.name ? info.name : ''}`.trim(),
+        });
+    }
+    handleScroll(e) {
+        if (!this.shouldRecord(e.target))
+            return;
+        const now = Date.now();
+        if (now - this.lastScrollTime < 1000)
+            return; // debounce 1s
+        this.lastScrollTime = now;
+        const el = e.target;
+        const isDoc = !el.tagName || el.tagName === 'HTML';
+        const scrollY = isDoc ? window.scrollY : el.scrollTop;
+        const scrollX = isDoc ? window.scrollX : el.scrollLeft;
+        const selector = el.tagName === 'HTML' || el.tagName === 'BODY'
+            ? 'window'
+            : this.buildSelector(el);
+        this.addAction({
+            type: 'scroll',
+            selector,
+            selectorStrategy: 'combined',
+            value: `${scrollX},${scrollY}`,
+            description: `Scroll to (${scrollX}, ${scrollY})`,
+        });
+    }
+    handleKeydown(e) {
+        const specialKeys = ['Enter', 'Escape', 'Tab', 'F5', 'F12'];
+        if (!specialKeys.includes(e.key))
+            return;
+        if (!this.shouldRecord(e.target))
+            return;
+        const el = e.target;
+        const selector = this.buildSelector(el);
+        this.addAction({
+            type: 'keypress',
+            selector,
+            selectorStrategy: this.getSelectorStrategy(el),
+            value: e.key,
+            description: `Press "${e.key}" on ${el.tagName.toLowerCase()}`,
+        });
+    }
+    recordNavigation(type, navUrl) {
+        const action = {
+            id: this.generateId(),
+            timestamp: Date.now(),
+            url: navUrl,
+            type,
+            selector: 'window',
+            selectorStrategy: 'combined',
+            description: `Navigate to ${navUrl}`,
+        };
+        this._currentSession.update(s => s ? { ...s, actions: [...s.actions, action] } : s);
+    }
+    // ─── Selector Building ────────────────────────────────────────────────────
+    buildSelector(el) {
+        // Priority: data-testid > data-cy > id > name > aria-label > combined
+        const testId = el.getAttribute('data-testid');
+        if (testId)
+            return `[data-testid="${testId}"]`;
+        const cy = el.getAttribute('data-cy');
+        if (cy)
+            return `[data-cy="${cy}"]`;
+        if (el.id && !el.id.includes(':'))
+            return `#${el.id}`;
+        const name = el.getAttribute('name');
+        if (name)
+            return `${el.tagName.toLowerCase()}[name="${name}"]`;
+        const ariaLabel = el.getAttribute('aria-label');
+        if (ariaLabel)
+            return `[aria-label="${ariaLabel}"]`;
+        // Class-based fallback
+        const relevantClasses = Array.from(el.classList)
+            .filter(c => !c.startsWith('ng-') && !c.startsWith('cdk-') && c.length > 0)
+            .slice(0, 3);
+        if (relevantClasses.length > 0) {
+            return `${el.tagName.toLowerCase()}.${relevantClasses.join('.')}`;
+        }
+        // Text content for buttons/links
+        if (['BUTTON', 'A'].includes(el.tagName)) {
+            const text = el.textContent?.trim().slice(0, 30);
+            if (text)
+                return `${el.tagName.toLowerCase()}:contains("${text}")`;
+        }
+        return el.tagName.toLowerCase();
+    }
+    getSelectorStrategy(el) {
+        if (el.getAttribute('data-testid'))
+            return 'data-testid';
+        if (el.getAttribute('data-cy'))
+            return 'data-cy';
+        if (el.id)
+            return 'id';
+        if (el.getAttribute('name'))
+            return 'name';
+        return 'class';
+    }
+    getElementInfo(el) {
+        return {
+            tagName: el.tagName.toLowerCase(),
+            id: el.id || undefined,
+            classes: Array.from(el.classList).filter(c => !c.startsWith('ng-')),
+            dataTestId: el.getAttribute('data-testid') || undefined,
+            dataCy: el.getAttribute('data-cy') || undefined,
+            name: el.getAttribute('name') || undefined,
+            type: el.getAttribute('type') || undefined,
+            placeholder: el.getAttribute('placeholder') || undefined,
+            text: el.textContent?.trim().slice(0, 50) || undefined,
+            href: el.href || undefined,
+            ariaLabel: el.getAttribute('aria-label') || undefined,
+        };
+    }
+    describeElement(info) {
+        if (info.dataTestId)
+            return `[data-testid="${info.dataTestId}"]`;
+        if (info.dataCy)
+            return `[data-cy="${info.dataCy}"]`;
+        if (info.id)
+            return `#${info.id}`;
+        if (info.ariaLabel)
+            return `"${info.ariaLabel}"`;
+        if (info.placeholder)
+            return `"${info.placeholder}" input`;
+        if (info.text)
+            return `"${info.text}"`;
+        return info.tagName;
+    }
+    // ─── Helpers ──────────────────────────────────────────────────────────────
+    shouldRecord(target) {
+        if (!this._isRecording() || this._isPaused())
+            return false;
+        if (!target)
+            return false;
+        // Ignore the debug panel itself
+        if (target.closest('[data-debug-panel]'))
+            return false;
+        return true;
+    }
+    addAction(partial) {
+        const action = {
+            id: this.generateId(),
+            timestamp: Date.now(),
+            url: window.location.href,
+            ...partial,
+        };
+        // Deduplicate consecutive identical inputs (keep only latest value)
+        if (action.type === 'input') {
+            this._currentSession.update(s => {
+                if (!s)
+                    return s;
+                const last = s.actions[s.actions.length - 1];
+                if (last?.type === 'input' && last.selector === action.selector) {
+                    return { ...s, actions: [...s.actions.slice(0, -1), action] };
+                }
+                return { ...s, actions: [...s.actions, action] };
+            });
+            return;
+        }
+        this._currentSession.update(s => s ? { ...s, actions: [...s.actions, action] } : s);
+    }
+    generateId() {
+        return Math.random().toString(36).slice(2, 11);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RecorderService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RecorderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RecorderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recorder.service.js","sourceRoot":"","sources":["../../../../../projects/debug-recorder/src/lib/services/recorder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, signal, computed } from '@angular/core';\r\nimport { ActionType, ElementInfo, RecordedAction, RecordingSession } from '../models/recorded-action.model';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class RecorderService {\r\n  private _isRecording = signal(false);\r\n  private _currentSession = signal<RecordingSession | null>(null);\r\n  private _sessions = signal<RecordingSession[]>([]);\r\n  private _isPaused = signal(false);\r\n\r\n  isRecording = computed(() => this._isRecording());\r\n  isPaused = computed(() => this._isPaused());\r\n  currentSession = computed(() => this._currentSession());\r\n  sessions = computed(() => this._sessions());\r\n  actionCount = computed(() => this._currentSession()?.actions.length ?? 0);\r\n\r\n  private listeners: Array<{ type: string; fn: EventListener }> = [];\r\n  private mutationObserver?: MutationObserver;\r\n\r\n  constructor(private zone: NgZone) {}\r\n\r\n  startRecording(name?: string, description?: string): void {\r\n    const session: RecordingSession = {\r\n      id: this.generateId(),\r\n      name: name || `Session ${new Date().toLocaleTimeString()}`,\r\n      description,\r\n      startTime: Date.now(),\r\n      startUrl: window.location.href,\r\n      actions: [],\r\n      tags: [],\r\n    };\r\n\r\n    this._currentSession.set(session);\r\n    this._isRecording.set(true);\r\n    this._isPaused.set(false);\r\n    this.attachListeners();\r\n    this.recordNavigation('navigation', window.location.href);\r\n  }\r\n\r\n  stopRecording(): RecordingSession | null {\r\n    const session = this._currentSession();\r\n    if (!session) return null;\r\n\r\n    const completed = { ...session, endTime: Date.now() };\r\n    this._sessions.update(s => [...s, completed]);\r\n    this._currentSession.set(null);\r\n    this._isRecording.set(false);\r\n    this._isPaused.set(false);\r\n    this.detachListeners();\r\n    return completed;\r\n  }\r\n\r\n  pauseRecording(): void {\r\n    if (this._isRecording()) {\r\n      this._isPaused.set(!this._isPaused());\r\n    }\r\n  }\r\n\r\n  clearCurrentSession(): void {\r\n    this._currentSession.update(s => s ? { ...s, actions: [] } : null);\r\n  }\r\n\r\n  removeAction(actionId: string): void {\r\n    this._currentSession.update(s =>\r\n      s ? { ...s, actions: s.actions.filter(a => a.id !== actionId) } : null\r\n    );\r\n  }\r\n\r\n  addNote(actionId: string, note: string): void {\r\n    this._currentSession.update(s =>\r\n      s ? {\r\n        ...s,\r\n        actions: s.actions.map(a => a.id === actionId ? { ...a, note } : a)\r\n      } : null\r\n    );\r\n  }\r\n\r\n  deleteSession(sessionId: string): void {\r\n    this._sessions.update(s => s.filter(x => x.id !== sessionId));\r\n  }\r\n\r\n  loadSession(session: RecordingSession): void {\r\n    this._currentSession.set(session);\r\n  }\r\n\r\n  // ─── Event Listeners ──────────────────────────────────────────────────────\r\n\r\n  private attachListeners(): void {\r\n    const opts = { capture: true, passive: true };\r\n\r\n    const onClick = (e: MouseEvent) => this.zone.run(() => this.handleClick(e));\r\n    const onDblClick = (e: MouseEvent) => this.zone.run(() => this.handleDblClick(e));\r\n    const onInput = (e: Event) => this.zone.run(() => this.handleInput(e));\r\n    const onChange = (e: Event) => this.zone.run(() => this.handleChange(e));\r\n    const onSubmit = (e: SubmitEvent) => this.zone.run(() => this.handleSubmit(e));\r\n    const onKeydown = (e: KeyboardEvent) => this.zone.run(() => this.handleKeydown(e));\r\n    const onScroll = (e: Event) => this.zone.run(() => this.handleScroll(e));\r\n\r\n    document.addEventListener('click', onClick, opts);\r\n    document.addEventListener('dblclick', onDblClick, opts);\r\n    document.addEventListener('input', onInput, opts);\r\n    document.addEventListener('change', onChange, opts);\r\n    document.addEventListener('submit', onSubmit, opts);\r\n    document.addEventListener('keydown', onKeydown, opts);\r\n    document.addEventListener('scroll', onScroll, { capture: true, passive: true });\r\n\r\n    this.listeners = [\r\n      { type: 'click', fn: onClick as EventListener },\r\n      { type: 'dblclick', fn: onDblClick as EventListener },\r\n      { type: 'input', fn: onInput as EventListener },\r\n      { type: 'change', fn: onChange as EventListener },\r\n      { type: 'submit', fn: onSubmit as EventListener },\r\n      { type: 'keydown', fn: onKeydown as EventListener },\r\n      { type: 'scroll', fn: onScroll as EventListener },\r\n    ];\r\n  }\r\n\r\n  private detachListeners(): void {\r\n    this.listeners.forEach(({ type, fn }) =>\r\n      document.removeEventListener(type, fn, true)\r\n    );\r\n    this.listeners = [];\r\n    this.mutationObserver?.disconnect();\r\n  }\r\n\r\n  // ─── Handlers ─────────────────────────────────────────────────────────────\r\n\r\n  private handleClick(e: MouseEvent): void {\r\n    if (!this.shouldRecord(e.target as Element)) return;\r\n    const el = e.target as HTMLElement;\r\n    const info = this.getElementInfo(el);\r\n    const selector = this.buildSelector(el);\r\n\r\n    this.addAction({\r\n      type: 'click',\r\n      selector,\r\n      selectorStrategy: this.getSelectorStrategy(el),\r\n      element: info,\r\n      description: `Click on ${this.describeElement(info)}`,\r\n    });\r\n  }\r\n\r\n  private handleDblClick(e: MouseEvent): void {\r\n    if (!this.shouldRecord(e.target as Element)) return;\r\n    const el = e.target as HTMLElement;\r\n    const info = this.getElementInfo(el);\r\n    const selector = this.buildSelector(el);\r\n\r\n    this.addAction({\r\n      type: 'dblclick',\r\n      selector,\r\n      selectorStrategy: this.getSelectorStrategy(el),\r\n      element: info,\r\n      description: `Double-click on ${this.describeElement(info)}`,\r\n    });\r\n  }\r\n\r\n  private handleInput(e: Event): void {\r\n    if (!this.shouldRecord(e.target as Element)) return;\r\n    const el = e.target as HTMLInputElement | HTMLTextAreaElement;\r\n    if (['checkbox', 'radio'].includes(el.type)) return; // handled by change\r\n    const info = this.getElementInfo(el);\r\n    const selector = this.buildSelector(el);\r\n\r\n    this.addAction({\r\n      type: 'input',\r\n      selector,\r\n      selectorStrategy: this.getSelectorStrategy(el),\r\n      element: info,\r\n      value: el.value,\r\n      description: `Type \"${el.value}\" in ${this.describeElement(info)}`,\r\n    });\r\n  }\r\n\r\n  private handleChange(e: Event): void {\r\n    if (!this.shouldRecord(e.target as Element)) return;\r\n    const el = e.target as HTMLSelectElement | HTMLInputElement;\r\n    const info = this.getElementInfo(el);\r\n    const selector = this.buildSelector(el);\r\n\r\n    if (el.tagName === 'SELECT') {\r\n      this.addAction({\r\n        type: 'select',\r\n        selector,\r\n        selectorStrategy: this.getSelectorStrategy(el),\r\n        element: info,\r\n        value: el.value,\r\n        description: `Select \"${el.value}\" in ${this.describeElement(info)}`,\r\n      });\r\n    } else if ((el as HTMLInputElement).type === 'checkbox') {\r\n      this.addAction({\r\n        type: 'click',\r\n        selector,\r\n        selectorStrategy: this.getSelectorStrategy(el),\r\n        element: info,\r\n        value: String((el as HTMLInputElement).checked),\r\n        description: `${(el as HTMLInputElement).checked ? 'Check' : 'Uncheck'} ${this.describeElement(info)}`,\r\n      });\r\n    }\r\n  }\r\n\r\n  private handleSubmit(e: SubmitEvent): void {\r\n    if (!this.shouldRecord(e.target as Element)) return;\r\n    const form = e.target as HTMLFormElement;\r\n    const info = this.getElementInfo(form);\r\n    const selector = this.buildSelector(form);\r\n\r\n    this.addAction({\r\n      type: 'submit',\r\n      selector,\r\n      selectorStrategy: this.getSelectorStrategy(form),\r\n      element: info,\r\n      description: `Submit form ${info.id ? '#' + info.id : info.name ? info.name : ''}`.trim(),\r\n    });\r\n  }\r\n\r\n  private lastScrollTime = 0;\r\n  private handleScroll(e: Event): void {\r\n    if (!this.shouldRecord(e.target as Element)) return;\r\n    const now = Date.now();\r\n    if (now - this.lastScrollTime < 1000) return; // debounce 1s\r\n    this.lastScrollTime = now;\r\n\r\n    const el = e.target as HTMLElement;\r\n    const isDoc = !el.tagName || el.tagName === 'HTML';\r\n    const scrollY = isDoc ? window.scrollY : el.scrollTop;\r\n    const scrollX = isDoc ? window.scrollX : el.scrollLeft;\r\n\r\n    const selector = el.tagName === 'HTML' || el.tagName === 'BODY'\r\n      ? 'window'\r\n      : this.buildSelector(el);\r\n\r\n    this.addAction({\r\n      type: 'scroll',\r\n      selector,\r\n      selectorStrategy: 'combined',\r\n      value: `${scrollX},${scrollY}`,\r\n      description: `Scroll to (${scrollX}, ${scrollY})`,\r\n    });\r\n  }\r\n\r\n  private handleKeydown(e: KeyboardEvent): void {\r\n    const specialKeys = ['Enter', 'Escape', 'Tab', 'F5', 'F12'];\r\n    if (!specialKeys.includes(e.key)) return;\r\n    if (!this.shouldRecord(e.target as Element)) return;\r\n\r\n    const el = e.target as HTMLElement;\r\n    const selector = this.buildSelector(el);\r\n\r\n    this.addAction({\r\n      type: 'keypress',\r\n      selector,\r\n      selectorStrategy: this.getSelectorStrategy(el),\r\n      value: e.key,\r\n      description: `Press \"${e.key}\" on ${el.tagName.toLowerCase()}`,\r\n    });\r\n  }\r\n\r\n  private recordNavigation(type: ActionType, navUrl: string): void {\r\n    const action: RecordedAction = {\r\n      id: this.generateId(),\r\n      timestamp: Date.now(),\r\n      url: navUrl,\r\n      type,\r\n      selector: 'window',\r\n      selectorStrategy: 'combined',\r\n      description: `Navigate to ${navUrl}`,\r\n    };\r\n    this._currentSession.update(s =>\r\n      s ? { ...s, actions: [...s.actions, action] } : s\r\n    );\r\n  }\r\n\r\n  // ─── Selector Building ────────────────────────────────────────────────────\r\n\r\n  private buildSelector(el: HTMLElement): string {\r\n    // Priority: data-testid > data-cy > id > name > aria-label > combined\r\n    const testId = el.getAttribute('data-testid');\r\n    if (testId) return `[data-testid=\"${testId}\"]`;\r\n\r\n    const cy = el.getAttribute('data-cy');\r\n    if (cy) return `[data-cy=\"${cy}\"]`;\r\n\r\n    if (el.id && !el.id.includes(':')) return `#${el.id}`;\r\n\r\n    const name = el.getAttribute('name');\r\n    if (name) return `${el.tagName.toLowerCase()}[name=\"${name}\"]`;\r\n\r\n    const ariaLabel = el.getAttribute('aria-label');\r\n    if (ariaLabel) return `[aria-label=\"${ariaLabel}\"]`;\r\n\r\n    // Class-based fallback\r\n    const relevantClasses = Array.from(el.classList)\r\n      .filter(c => !c.startsWith('ng-') && !c.startsWith('cdk-') && c.length > 0)\r\n      .slice(0, 3);\r\n    if (relevantClasses.length > 0) {\r\n      return `${el.tagName.toLowerCase()}.${relevantClasses.join('.')}`;\r\n    }\r\n\r\n    // Text content for buttons/links\r\n    if (['BUTTON', 'A'].includes(el.tagName)) {\r\n      const text = el.textContent?.trim().slice(0, 30);\r\n      if (text) return `${el.tagName.toLowerCase()}:contains(\"${text}\")`;\r\n    }\r\n\r\n    return el.tagName.toLowerCase();\r\n  }\r\n\r\n  private getSelectorStrategy(el: HTMLElement): RecordedAction['selectorStrategy'] {\r\n    if (el.getAttribute('data-testid')) return 'data-testid';\r\n    if (el.getAttribute('data-cy')) return 'data-cy';\r\n    if (el.id) return 'id';\r\n    if (el.getAttribute('name')) return 'name';\r\n    return 'class';\r\n  }\r\n\r\n  private getElementInfo(el: HTMLElement): ElementInfo {\r\n    return {\r\n      tagName: el.tagName.toLowerCase(),\r\n      id: el.id || undefined,\r\n      classes: Array.from(el.classList).filter(c => !c.startsWith('ng-')),\r\n      dataTestId: el.getAttribute('data-testid') || undefined,\r\n      dataCy: el.getAttribute('data-cy') || undefined,\r\n      name: el.getAttribute('name') || undefined,\r\n      type: el.getAttribute('type') || undefined,\r\n      placeholder: el.getAttribute('placeholder') || undefined,\r\n      text: el.textContent?.trim().slice(0, 50) || undefined,\r\n      href: (el as HTMLAnchorElement).href || undefined,\r\n      ariaLabel: el.getAttribute('aria-label') || undefined,\r\n    };\r\n  }\r\n\r\n  private describeElement(info: ElementInfo): string {\r\n    if (info.dataTestId) return `[data-testid=\"${info.dataTestId}\"]`;\r\n    if (info.dataCy) return `[data-cy=\"${info.dataCy}\"]`;\r\n    if (info.id) return `#${info.id}`;\r\n    if (info.ariaLabel) return `\"${info.ariaLabel}\"`;\r\n    if (info.placeholder) return `\"${info.placeholder}\" input`;\r\n    if (info.text) return `\"${info.text}\"`;\r\n    return info.tagName;\r\n  }\r\n\r\n  // ─── Helpers ──────────────────────────────────────────────────────────────\r\n\r\n  private shouldRecord(target: Element | null): boolean {\r\n    if (!this._isRecording() || this._isPaused()) return false;\r\n    if (!target) return false;\r\n    // Ignore the debug panel itself\r\n    if (target.closest('[data-debug-panel]')) return false;\r\n    return true;\r\n  }\r\n\r\n  private addAction(partial: Omit<RecordedAction, 'id' | 'timestamp' | 'url'>): void {\r\n    const action: RecordedAction = {\r\n      id: this.generateId(),\r\n      timestamp: Date.now(),\r\n      url: window.location.href,\r\n      ...partial,\r\n    };\r\n\r\n    // Deduplicate consecutive identical inputs (keep only latest value)\r\n    if (action.type === 'input') {\r\n      this._currentSession.update(s => {\r\n        if (!s) return s;\r\n        const last = s.actions[s.actions.length - 1];\r\n        if (last?.type === 'input' && last.selector === action.selector) {\r\n          return { ...s, actions: [...s.actions.slice(0, -1), action] };\r\n        }\r\n        return { ...s, actions: [...s.actions, action] };\r\n      });\r\n      return;\r\n    }\r\n\r\n    this._currentSession.update(s =>\r\n      s ? { ...s, actions: [...s.actions, action] } : s\r\n    );\r\n  }\r\n\r\n  private generateId(): string {\r\n    return Math.random().toString(36).slice(2, 11);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/rrweb-recorder.service.mjs

@@ -0,0 +1,108 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RrwebRecorderService {
+    constructor(zone) {
+        this.zone = zone;
+        this._events = signal([]);
+        this._isRecording = signal(false);
+        this.events = this._events.asReadonly();
+        this.isRecording = this._isRecording.asReadonly();
+    }
+    async startRecording() {
+        // Dynamically import rrweb to avoid SSR issues and reduce initial bundle
+        const { record } = await import('rrweb');
+        this._events.set([]);
+        this._isRecording.set(true);
+        this.stopFn = record({
+            emit: (event) => {
+                this.zone.run(() => {
+                    this._events.update(ev => [...ev, event]);
+                });
+            },
+            // Note: blockSelector is omitted — rrweb 2.0.0-alpha.4 calls node.matches()
+            // on TextNodes/CommentNodes which don't have that method, crashing the recorder.
+            maskTextSelector: 'input[type="password"]',
+            checkoutEveryNth: 200,
+        });
+    }
+    stopRecording() {
+        if (this.stopFn) {
+            this.stopFn();
+            this.stopFn = undefined;
+        }
+        this._isRecording.set(false);
+        return this._events();
+    }
+    getEvents() {
+        return this._events();
+    }
+    clearEvents() {
+        this._events.set([]);
+    }
+    hasEvents() {
+        return this._events().length > 0;
+    }
+    // ─── Replay ──────────────────────────────────────────────────────────────
+    async startReplay(container, events) {
+        const { Replayer } = await import('rrweb');
+        const eventsToReplay = events ?? this._events();
+        if (eventsToReplay.length === 0)
+            return;
+        // Destroy previous replayer
+        this.destroyReplayer();
+        this.replayer = new Replayer(eventsToReplay, {
+            root: container,
+            skipInactive: true,
+            showWarning: false,
+            showDebug: false,
+            blockClass: 'debug-panel',
+        });
+        this.replayer.play();
+    }
+    pauseReplay() {
+        this.replayer?.pause();
+    }
+    resumeReplay() {
+        this.replayer?.play();
+    }
+    destroyReplayer() {
+        if (this.replayer) {
+            try {
+                this.replayer.pause();
+            }
+            catch { }
+            this.replayer = undefined;
+        }
+    }
+    // ─── Export ───────────────────────────────────────────────────────────────
+    exportEvents() {
+        return JSON.stringify(this._events(), null, 2);
+    }
+    downloadEvents(filename = 'rrweb-session.json') {
+        const blob = new Blob([this.exportEvents()], { type: 'application/json' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        a.click();
+        URL.revokeObjectURL(url);
+    }
+    importEvents(json) {
+        try {
+            const events = JSON.parse(json);
+            this._events.set(events);
+            return events;
+        }
+        catch {
+            console.error('Invalid rrweb events JSON');
+            return [];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RrwebRecorderService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RrwebRecorderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RrwebRecorderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rrweb-recorder.service.js","sourceRoot":"","sources":["../../../../../projects/debug-recorder/src/lib/services/rrweb-recorder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, signal } from '@angular/core';\r\nimport type { eventWithTime } from '@rrweb/types';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class RrwebRecorderService {\r\n  private _events = signal<eventWithTime[]>([]);\r\n  private _isRecording = signal(false);\r\n  private stopFn?: () => void;\r\n  private replayer?: any;\r\n\r\n  events = this._events.asReadonly();\r\n  isRecording = this._isRecording.asReadonly();\r\n\r\n  constructor(private zone: NgZone) {}\r\n\r\n  async startRecording(): Promise<void> {\r\n    // Dynamically import rrweb to avoid SSR issues and reduce initial bundle\r\n    const { record } = await import('rrweb');\r\n    this._events.set([]);\r\n    this._isRecording.set(true);\r\n\r\n    this.stopFn = record({\r\n      emit: (event: eventWithTime) => {\r\n        this.zone.run(() => {\r\n          this._events.update(ev => [...ev, event]);\r\n        });\r\n      },\r\n      // Note: blockSelector is omitted — rrweb 2.0.0-alpha.4 calls node.matches()\r\n      // on TextNodes/CommentNodes which don't have that method, crashing the recorder.\r\n      maskTextSelector: 'input[type=\"password\"]',\r\n      checkoutEveryNth: 200,\r\n    });\r\n  }\r\n\r\n  stopRecording(): eventWithTime[] {\r\n    if (this.stopFn) {\r\n      this.stopFn();\r\n      this.stopFn = undefined;\r\n    }\r\n    this._isRecording.set(false);\r\n    return this._events();\r\n  }\r\n\r\n  getEvents(): eventWithTime[] {\r\n    return this._events();\r\n  }\r\n\r\n  clearEvents(): void {\r\n    this._events.set([]);\r\n  }\r\n\r\n  hasEvents(): boolean {\r\n    return this._events().length > 0;\r\n  }\r\n\r\n  // ─── Replay ──────────────────────────────────────────────────────────────\r\n\r\n  async startReplay(container: HTMLElement, events?: eventWithTime[]): Promise<void> {\r\n    const { Replayer } = await import('rrweb');\r\n    const eventsToReplay = events ?? this._events();\r\n\r\n    if (eventsToReplay.length === 0) return;\r\n\r\n    // Destroy previous replayer\r\n    this.destroyReplayer();\r\n\r\n    this.replayer = new Replayer(eventsToReplay, {\r\n      root: container,\r\n      skipInactive: true,\r\n      showWarning: false,\r\n      showDebug: false,\r\n      blockClass: 'debug-panel',\r\n    });\r\n\r\n    this.replayer.play();\r\n  }\r\n\r\n  pauseReplay(): void {\r\n    this.replayer?.pause();\r\n  }\r\n\r\n  resumeReplay(): void {\r\n    this.replayer?.play();\r\n  }\r\n\r\n  destroyReplayer(): void {\r\n    if (this.replayer) {\r\n      try { this.replayer.pause(); } catch {}\r\n      this.replayer = undefined;\r\n    }\r\n  }\r\n\r\n  // ─── Export ───────────────────────────────────────────────────────────────\r\n\r\n  exportEvents(): string {\r\n    return JSON.stringify(this._events(), null, 2);\r\n  }\r\n\r\n  downloadEvents(filename = 'rrweb-session.json'): void {\r\n    const blob = new Blob([this.exportEvents()], { type: 'application/json' });\r\n    const url = URL.createObjectURL(blob);\r\n    const a = document.createElement('a');\r\n    a.href = url;\r\n    a.download = filename;\r\n    a.click();\r\n    URL.revokeObjectURL(url);\r\n  }\r\n\r\n  importEvents(json: string): eventWithTime[] {\r\n    try {\r\n      const events = JSON.parse(json) as eventWithTime[];\r\n      this._events.set(events);\r\n      return events;\r\n    } catch {\r\n      console.error('Invalid rrweb events JSON');\r\n      return [];\r\n    }\r\n  }\r\n}\r\n"]}