@futdevpro/fdp-e2e-helpers 1.15.10 → 1.15.14

package/build/_collections/fdp-cwv-collector.util.d.ts

@@ -0,0 +1,110 @@
+import { Page } from '@playwright/test';
+import { FDP_CWV_RunConfig_Interface } from '../_models/interfaces/fdp-cwv-run-config.interface';
+import { FDP_CWV_RouteConfig_Interface } from '../_models/interfaces/fdp-cwv-route-config.interface';
+import { FDP_CWV_Result_Interface } from '../_models/interfaces/fdp-cwv-result.interface';
+import { FDP_CWV_RouteResult_Interface } from '../_models/interfaces/fdp-cwv-route-result.interface';
+import { FDP_CWV_RawMetric_Interface } from '../_models/interfaces/fdp-cwv-raw-metric.interface';
+import { FDP_CWV_Budgets_Interface } from '../_models/interfaces/fdp-cwv-budgets.interface';
+/**
+ * FDP_CWV_Collector_Util — scriptelt, szintetikus Core Web Vitals diagnosztika
+ * Playwright + web-vitals/attribution alapon.
+ *
+ * Hasznalat (a fogyaszto e2e projektben, ahol a require.resolve megengedett):
+ * ```
+ * const wv = fs.readFileSync(require.resolve('web-vitals/dist/web-vitals.attribution.iife.js'), 'utf-8');
+ * const result = await FDP_CWV_Collector_Util.collect(page, { routes, webVitalsScript: wv, budgets });
+ * FDP_CWV_Collector_Util.writeResult(result, './logs/cicd-pipeline/diagnostics/cwv-diag.json');
+ * ```
+ *
+ * Mukodes route-onkent: (1) navigacio, (2) opcionalis interakcio az INP-hez,
+ * (3) KOTELEZO visibility-hidden flush (e nelkul az INP/CLS ures), (4) metrika-olvasas.
+ *
+ * Stateless static class — NO singleton-state, multi-call-safe.
+ */
+export declare class FDP_CWV_Collector_Util {
+    /** web-vitals standard rating-kuszobok [good-felso, needs-improvement-felso]. */
+    static readonly THRESHOLDS: {
+        [key: string]: [number, number];
+    };
+    /**
+     * Egy teljes CWV diag-futas: minden konfiguralt route-ot megmer, es osszesitett
+     * tipizalt eredmenyt ad vissza. A `page`-et a hivo birtokolja (browser-lifecycle
+     * a Playwright test-frameworke); a collector csak vezerli.
+     */
+    static collect(page: Page, config: FDP_CWV_RunConfig_Interface): Promise<FDP_CWV_Result_Interface>;
+    /**
+     * Egy route nyers metrikaibol epit tipizalt route-eredmenyt + budget-kiertekeles.
+     */
+    static buildRouteResult(route: FDP_CWV_RouteConfig_Interface, label: string, raw: FDP_CWV_RawMetric_Interface[], budgets?: FDP_CWV_Budgets_Interface): FDP_CWV_RouteResult_Interface;
+    /**
+     * Pure budget-kiertekeles: mely metrikak vannak a konfiguralt budget FOLOTT.
+     * Unit-testelheto (nem igenyel bongeszot).
+     */
+    static evaluateBudgets(values: {
+        lcp?: number;
+        inp?: number;
+        cls?: number;
+    }, budgets?: FDP_CWV_Budgets_Interface): string[];
+    /**
+     * Pure rating-szamitas a web-vitals standard kuszobok szerint (fallback, ha a
+     * library `rating`-je hianyzik). Unit-testelheto.
+     */
+    static rate(name: string, value: number): 'good' | 'needs-improvement' | 'poor';
+    /**
+     * A legrosszabb (legnagyobb) ertekek az osszes route-on — trend-projekciohoz.
+     */
+    static summarizeWorst(routes: FDP_CWV_RouteResult_Interface[]): {
+        lcpMs?: number;
+        inpMs?: number;
+        cls?: number;
+    };
+    /**
+     * OPCIONALIS lokalis JSON artifact kiirasa (debug / archivalas). A CI-ban a
+     * kanonikus ut a `printStepResultMarker` (a step-eredmeny markerkent megy a
+     * report-ba) — ez a metodus csak akkor kell, ha kulon fajl-artifact is kell.
+     * Az envelope: `{ type:'cwv', name, status, summary, data:<FDP_CWV_Result> }`.
+     * Letrehozza a hianyzo konyvtarakat.
+     */
+    static writeResult(result: FDP_CWV_Result_Interface, outputPath: string): void;
+    /**
+     * Kibocsatja a generikus `[CDP_STEP_RESULT] {json}` marker-t a stdout-ra, amibol
+     * a `dc cdp` step-runner a step entry `message`/`detail` mezojebe teszi az
+     * eredmenyt — igy a CWV "csak az egyik step eredmenye" lesz, KULON diagnostics-
+     * koncepcio nelkul. A `message` egysoros osszegzes (-> CICD result step.message),
+     * a `detail` a teljes strukturalt result (-> cdpReport-ban utazik az Overseerig).
+     *
+     * EGYSOROS compact JSON (a step-runner soronkent olvas) — ezert a sajat sorat
+     * kapja, sose tordeld.
+     */
+    static printStepResultMarker(result: FDP_CWV_Result_Interface): void;
+    /**
+     * A `writeResult` altal kiirt envelope-fajlbol bocsatja ki a `[CDP_STEP_RESULT]`
+     * marker-t. CI-ban EZ a megbizhato ut: a e2e spec fajlba irja az eredmenyt
+     * (`writeResult`), majd a pipeline step a Playwright-futas UTAN egy `node` hivassal
+     * ezt meghivja — igy a marker KOZVETLENUL a step shell-stdout-jara kerul (NEM a
+     * Playwright reporter-en at, ami befolythatna/prefixelhetne a sort).
+     *
+     * Hasznalat a pipeline step parancsban:
+     *   node -e "require('@futdevpro/fdp-e2e-helpers').FDP_CWV_Collector_Util.emitMarkerFromFile('cwv-result.json')"
+     */
+    static emitMarkerFromFile(filePath: string): void;
+    /**
+     * Egysoros, ember-olvashato osszegzes a CLI / Discord / dashboard renderhez.
+     * Pl. "3 route, worst LCP 3200ms, INP 250ms, CLS 0.050 (budget túllépés!)".
+     */
+    static buildSummaryLine(result: FDP_CWV_Result_Interface): string;
+    /**
+     * Origin (protocol+host) kinyerese egy URL-bol — robusztus malformed-re.
+     */
+    static extractOrigin(url: string): string;
+    /**
+     * Visibility-hidden + pagehide szimulacio — ez kenyszeríti ki a web-vitals
+     * vegso INP/CLS/LCP callback-jeit. A kovetkezo navigacio friss document-tel resetel.
+     */
+    private static forceVisibilityHidden;
+    /**
+     * Helper: error -> rovid uzenet (DyFM_Error / Error / string / unknown).
+     */
+    private static errMsg;
+}
+//# sourceMappingURL=fdp-cwv-collector.util.d.ts.map

package/build/_collections/fdp-cwv-collector.util.js

@@ -0,0 +1,383 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FDP_CWV_Collector_Util = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+/**
+ * Bongeszo-oldali SETUP — `page.addInitScript`-en at fut, MINDEN navigaciora ujra.
+ * Felteszi hogy a web-vitals/attribution IIFE mar definialta a `window.webVitals`-t
+ * (a collector ezt elobb injektalja). Regisztralja az onLCP/onINP/onCLS/onFCP/onTTFB
+ * callback-eket egy `window.__fdpCwv` gyujtore.
+ *
+ * FONTOS: standalone fuggveny (NEM hivatkozhat kulso scope-ra a `prefixes` argon kivul),
+ * mert a Playwright serializalja es a bongeszoben futtatja.
+ */
+const FDP_CWV_browserSetup = (prefixes) => {
+    const w = window;
+    if (!w.webVitals) {
+        return;
+    }
+    w.__fdpCwv = [];
+    const store = w.__fdpCwv;
+    // generateTarget: a kivalto elemhez megkeresi a legkozelebbi FDP-komponens host-ot
+    // (olyan custom-element, aminek a tag-prefixe a `prefixes`-ben van), es elere fuzi.
+    const generateTarget = (node) => {
+        try {
+            const el = node;
+            if (!el || !el.tagName) {
+                return 'unknown';
+            }
+            let componentTag = '';
+            let walker = el;
+            while (walker && walker.tagName) {
+                const tag = walker.tagName.toLowerCase();
+                const isComponent = tag.indexOf('-') > -1 &&
+                    (!prefixes.length || prefixes.some((p) => tag.indexOf(p) === 0));
+                if (isComponent) {
+                    componentTag = tag;
+                    break;
+                }
+                walker = walker.parentElement;
+            }
+            const base = el.tagName.toLowerCase();
+            const id = el.id ? `#${el.id}` : '';
+            const selector = `${base}${id}`;
+            return componentTag ? `${componentTag} >> ${selector}` : selector;
+        }
+        catch {
+            return 'unknown';
+        }
+    };
+    const opts = {
+        reportAllChanges: false,
+        generateTarget: generateTarget,
+    };
+    const push = (m) => {
+        store.push(m);
+    };
+    // LCP/INP/CLS kapja a generateTarget-et (van target-juk); FCP/TTFB nem.
+    w.webVitals.onLCP(push, opts);
+    w.webVitals.onINP(push, opts);
+    w.webVitals.onCLS(push, opts);
+    w.webVitals.onFCP(push);
+    w.webVitals.onTTFB(push);
+};
+/**
+ * Bongeszo-oldali READ — `page.evaluate`-en at. A nyers web-vitals metrikakbol
+ * kiemeli a serializalhato mezoket (a nyers PerformanceEntry-ket NEM viszi at).
+ * Az attribution mezoneveit allowlist-tel masolja (v3/v4-robusztus).
+ */
+const FDP_CWV_browserRead = () => {
+    const w = window;
+    const raw = w.__fdpCwv || [];
+    const NUM_KEYS = [
+        'timeToFirstByte', 'resourceLoadDelay', 'resourceLoadDuration', 'elementRenderDelay',
+        'inputDelay', 'processingDuration', 'presentationDelay', 'largestShiftValue', 'largestShiftTime',
+    ];
+    const STR_KEYS = ['url', 'interactionType'];
+    const TARGET_KEYS = ['target', 'element', 'interactionTarget', 'largestShiftTarget'];
+    return raw.map((m) => {
+        const attrRaw = m['attribution'] || {};
+        const attribution = {};
+        for (const key of TARGET_KEYS) {
+            if (typeof attrRaw[key] === 'string' && attrRaw[key]) {
+                attribution['target'] = attrRaw[key];
+                break;
+            }
+        }
+        for (const key of STR_KEYS) {
+            if (typeof attrRaw[key] === 'string') {
+                attribution[key] = attrRaw[key];
+            }
+        }
+        for (const key of NUM_KEYS) {
+            if (typeof attrRaw[key] === 'number') {
+                attribution[key] = Math.round(attrRaw[key]);
+            }
+        }
+        return {
+            name: m['name'],
+            value: m['value'],
+            rating: m['rating'] || 'good',
+            attribution: attribution,
+        };
+    });
+};
+/**
+ * FDP_CWV_Collector_Util — scriptelt, szintetikus Core Web Vitals diagnosztika
+ * Playwright + web-vitals/attribution alapon.
+ *
+ * Hasznalat (a fogyaszto e2e projektben, ahol a require.resolve megengedett):
+ * ```
+ * const wv = fs.readFileSync(require.resolve('web-vitals/dist/web-vitals.attribution.iife.js'), 'utf-8');
+ * const result = await FDP_CWV_Collector_Util.collect(page, { routes, webVitalsScript: wv, budgets });
+ * FDP_CWV_Collector_Util.writeResult(result, './logs/cicd-pipeline/diagnostics/cwv-diag.json');
+ * ```
+ *
+ * Mukodes route-onkent: (1) navigacio, (2) opcionalis interakcio az INP-hez,
+ * (3) KOTELEZO visibility-hidden flush (e nelkul az INP/CLS ures), (4) metrika-olvasas.
+ *
+ * Stateless static class — NO singleton-state, multi-call-safe.
+ */
+class FDP_CWV_Collector_Util {
+    /** web-vitals standard rating-kuszobok [good-felso, needs-improvement-felso]. */
+    static THRESHOLDS = {
+        LCP: [2500, 4000],
+        INP: [200, 500],
+        CLS: [0.1, 0.25],
+        FCP: [1800, 3000],
+        TTFB: [800, 1800],
+    };
+    /**
+     * Egy teljes CWV diag-futas: minden konfiguralt route-ot megmer, es osszesitett
+     * tipizalt eredmenyt ad vissza. A `page`-et a hivo birtokolja (browser-lifecycle
+     * a Playwright test-frameworke); a collector csak vezerli.
+     */
+    static async collect(page, config) {
+        const prefixes = config.componentPrefixes ?? [];
+        const flushTimeout = config.flushTimeoutMs ?? 600;
+        const navTimeout = config.navigationTimeoutMs ?? 20000;
+        // Egyszer regisztraljuk — mindketto MINDEN navigaciora ujra fut (web-vitals reset).
+        // A web-vitals IIFE `var webVitals=...`-t csinal; a Playwright addInitScript viszont
+        // FUGGVENY-SCOPE-ba wrappeli a scriptet, igy a top-level `var` NEM kerul a window-ra.
+        // Ezert ugyanabban a scope-ban (a var utan) explicit ra-attach-oljuk a global-ra.
+        const webVitalsInjection = `${config.webVitalsScript}\n;try{self.webVitals=self.webVitals||webVitals;}catch(e){}`;
+        await page.addInitScript(webVitalsInjection);
+        await page.addInitScript(FDP_CWV_browserSetup, prefixes);
+        const routeResults = [];
+        let baseUrl = '';
+        for (const route of config.routes) {
+            const label = route.label ?? route.path;
+            fsm_dynamo_1.DyFM_Log.info(`[FDP_CWV] Mérés: ${label} (${route.path})`);
+            await page.goto(route.path, { waitUntil: 'load', timeout: navTimeout });
+            if (!baseUrl) {
+                baseUrl = FDP_CWV_Collector_Util.extractOrigin(page.url());
+            }
+            await page.waitForLoadState('networkidle', { timeout: navTimeout }).catch(() => undefined);
+            if (route.waitForSelector) {
+                await page.waitForSelector(route.waitForSelector, { timeout: navTimeout }).catch(() => null);
+            }
+            if (route.interact) {
+                try {
+                    await route.interact(page);
+                }
+                catch (error) {
+                    fsm_dynamo_1.DyFM_Log.warn(`[FDP_CWV] interact() hiba a(z) ${label} route-on: ${FDP_CWV_Collector_Util.errMsg(error)}`);
+                }
+            }
+            // KOTELEZO flush: az onINP/onCLS/onLCP csak visibility-hidden-re adja a vegso erteket.
+            await FDP_CWV_Collector_Util.forceVisibilityHidden(page);
+            await page.waitForTimeout(flushTimeout);
+            const raw = await page.evaluate(FDP_CWV_browserRead);
+            routeResults.push(FDP_CWV_Collector_Util.buildRouteResult(route, label, raw, config.budgets));
+        }
+        const worst = FDP_CWV_Collector_Util.summarizeWorst(routeResults);
+        const anyOverBudget = routeResults.some((r) => r.overBudget.length > 0);
+        return {
+            collectedAt: new Date().toISOString(),
+            baseUrl: baseUrl,
+            budgets: config.budgets,
+            routes: routeResults,
+            worst: worst,
+            anyOverBudget: anyOverBudget,
+            status: anyOverBudget ? 'warn' : 'ok',
+        };
+    }
+    /**
+     * Egy route nyers metrikaibol epit tipizalt route-eredmenyt + budget-kiertekeles.
+     */
+    static buildRouteResult(route, label, raw, budgets) {
+        const byName = new Map();
+        for (const m of raw) {
+            byName.set(m.name, m); // last-wins (reportAllChanges:false eseten egy is van)
+        }
+        const toMetric = (m) => m ? { value: m.value, rating: m.rating, attribution: m.attribution } : undefined;
+        const lcp = toMetric(byName.get('LCP'));
+        const inp = toMetric(byName.get('INP'));
+        const cls = toMetric(byName.get('CLS'));
+        const fcp = toMetric(byName.get('FCP'));
+        const ttfb = toMetric(byName.get('TTFB'));
+        const overBudget = FDP_CWV_Collector_Util.evaluateBudgets({ lcp: lcp?.value, inp: inp?.value, cls: cls?.value }, budgets);
+        return {
+            route: route.path,
+            label: label,
+            lcp: lcp,
+            inp: inp,
+            cls: cls,
+            fcp: fcp,
+            ttfb: ttfb,
+            overBudget: overBudget,
+        };
+    }
+    /**
+     * Pure budget-kiertekeles: mely metrikak vannak a konfiguralt budget FOLOTT.
+     * Unit-testelheto (nem igenyel bongeszot).
+     */
+    static evaluateBudgets(values, budgets) {
+        const over = [];
+        if (!budgets) {
+            return over;
+        }
+        if (values.lcp != null && budgets.lcpMs != null && values.lcp > budgets.lcpMs) {
+            over.push('lcp');
+        }
+        if (values.inp != null && budgets.inpMs != null && values.inp > budgets.inpMs) {
+            over.push('inp');
+        }
+        if (values.cls != null && budgets.cls != null && values.cls > budgets.cls) {
+            over.push('cls');
+        }
+        return over;
+    }
+    /**
+     * Pure rating-szamitas a web-vitals standard kuszobok szerint (fallback, ha a
+     * library `rating`-je hianyzik). Unit-testelheto.
+     */
+    static rate(name, value) {
+        const t = FDP_CWV_Collector_Util.THRESHOLDS[name];
+        if (!t) {
+            return 'good';
+        }
+        if (value <= t[0]) {
+            return 'good';
+        }
+        if (value <= t[1]) {
+            return 'needs-improvement';
+        }
+        return 'poor';
+    }
+    /**
+     * A legrosszabb (legnagyobb) ertekek az osszes route-on — trend-projekciohoz.
+     */
+    static summarizeWorst(routes) {
+        const worst = {};
+        for (const r of routes) {
+            if (r.lcp) {
+                worst.lcpMs = Math.max(worst.lcpMs ?? 0, r.lcp.value);
+            }
+            if (r.inp) {
+                worst.inpMs = Math.max(worst.inpMs ?? 0, r.inp.value);
+            }
+            if (r.cls) {
+                worst.cls = Math.max(worst.cls ?? 0, r.cls.value);
+            }
+        }
+        return worst;
+    }
+    /**
+     * OPCIONALIS lokalis JSON artifact kiirasa (debug / archivalas). A CI-ban a
+     * kanonikus ut a `printStepResultMarker` (a step-eredmeny markerkent megy a
+     * report-ba) — ez a metodus csak akkor kell, ha kulon fajl-artifact is kell.
+     * Az envelope: `{ type:'cwv', name, status, summary, data:<FDP_CWV_Result> }`.
+     * Letrehozza a hianyzo konyvtarakat.
+     */
+    static writeResult(result, outputPath) {
+        const dir = path.dirname(outputPath);
+        fs.mkdirSync(dir, { recursive: true });
+        const envelope = {
+            type: 'cwv',
+            name: 'Core Web Vitals',
+            status: result.status,
+            summary: FDP_CWV_Collector_Util.buildSummaryLine(result),
+            data: result,
+        };
+        fs.writeFileSync(outputPath, JSON.stringify(envelope, null, 2), 'utf-8');
+        fsm_dynamo_1.DyFM_Log.info(`[FDP_CWV] Eredmény kiírva: ${outputPath} (status=${result.status})`);
+    }
+    /**
+     * Kibocsatja a generikus `[CDP_STEP_RESULT] {json}` marker-t a stdout-ra, amibol
+     * a `dc cdp` step-runner a step entry `message`/`detail` mezojebe teszi az
+     * eredmenyt — igy a CWV "csak az egyik step eredmenye" lesz, KULON diagnostics-
+     * koncepcio nelkul. A `message` egysoros osszegzes (-> CICD result step.message),
+     * a `detail` a teljes strukturalt result (-> cdpReport-ban utazik az Overseerig).
+     *
+     * EGYSOROS compact JSON (a step-runner soronkent olvas) — ezert a sajat sorat
+     * kapja, sose tordeld.
+     */
+    static printStepResultMarker(result) {
+        const payload = {
+            message: FDP_CWV_Collector_Util.buildSummaryLine(result),
+            detail: result,
+        };
+        // Sajat sor, compact JSON — a `[CDP_STEP_RESULT]` marker-regex egy soron varja.
+        process.stdout.write(`\n[CDP_STEP_RESULT] ${JSON.stringify(payload)}\n`);
+    }
+    /**
+     * A `writeResult` altal kiirt envelope-fajlbol bocsatja ki a `[CDP_STEP_RESULT]`
+     * marker-t. CI-ban EZ a megbizhato ut: a e2e spec fajlba irja az eredmenyt
+     * (`writeResult`), majd a pipeline step a Playwright-futas UTAN egy `node` hivassal
+     * ezt meghivja — igy a marker KOZVETLENUL a step shell-stdout-jara kerul (NEM a
+     * Playwright reporter-en at, ami befolythatna/prefixelhetne a sort).
+     *
+     * Hasznalat a pipeline step parancsban:
+     *   node -e "require('@futdevpro/fdp-e2e-helpers').FDP_CWV_Collector_Util.emitMarkerFromFile('cwv-result.json')"
+     */
+    static emitMarkerFromFile(filePath) {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        // Envelope (`{ ..., data }`) vagy nyers result is elfogadott.
+        const result = (parsed.data ?? parsed);
+        FDP_CWV_Collector_Util.printStepResultMarker(result);
+    }
+    /**
+     * Egysoros, ember-olvashato osszegzes a CLI / Discord / dashboard renderhez.
+     * Pl. "3 route, worst LCP 3200ms, INP 250ms, CLS 0.050 (budget túllépés!)".
+     */
+    static buildSummaryLine(result) {
+        const parts = [`${result.routes.length} route`];
+        if (result.worst.lcpMs != null) {
+            parts.push(`worst LCP ${Math.round(result.worst.lcpMs)}ms`);
+        }
+        if (result.worst.inpMs != null) {
+            parts.push(`INP ${Math.round(result.worst.inpMs)}ms`);
+        }
+        if (result.worst.cls != null) {
+            parts.push(`CLS ${result.worst.cls.toFixed(3)}`);
+        }
+        if (result.anyOverBudget) {
+            parts.push('(budget túllépés!)');
+        }
+        return parts.join(', ');
+    }
+    /**
+     * Origin (protocol+host) kinyerese egy URL-bol — robusztus malformed-re.
+     */
+    static extractOrigin(url) {
+        try {
+            return new URL(url).origin;
+        }
+        catch {
+            return url;
+        }
+    }
+    /**
+     * Visibility-hidden + pagehide szimulacio — ez kenyszeríti ki a web-vitals
+     * vegso INP/CLS/LCP callback-jeit. A kovetkezo navigacio friss document-tel resetel.
+     */
+    static async forceVisibilityHidden(page) {
+        await page.evaluate(() => {
+            try {
+                Object.defineProperty(document, 'visibilityState', { configurable: true, get: () => 'hidden' });
+                Object.defineProperty(document, 'hidden', { configurable: true, get: () => true });
+            }
+            catch {
+                // ignore — ha mar redefinialt, a dispatch onmagaban is triggerel
+            }
+            document.dispatchEvent(new Event('visibilitychange'));
+            window.dispatchEvent(new Event('pagehide'));
+        });
+    }
+    /**
+     * Helper: error -> rovid uzenet (DyFM_Error / Error / string / unknown).
+     */
+    static errMsg(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return typeof error === 'string' ? error : JSON.stringify(error ?? {}).substring(0, 200);
+    }
+}
+exports.FDP_CWV_Collector_Util = FDP_CWV_Collector_Util;
+//# sourceMappingURL=fdp-cwv-collector.util.js.map

package/build/_models/interfaces/fdp-cwv-attribution.interface.d.ts

@@ -0,0 +1,40 @@
+/**
+ * CWV attribution — a kiváltó ok beazonosításához.
+ *
+ * A `web-vitals/attribution` build adja: nem csak a metrika-értéket, hanem a
+ * kiváltó DOM-elemet (selector) + a fázis-breakdown-t. Minden mező opcionális,
+ * mert metrikánként más-más releváns (a collector csak a primitív/string mezőket
+ * emeli ki, hogy a result JSON-serializálható maradjon — nyers PerformanceEntry-t
+ * NEM viszünk át).
+ */
+export interface FDP_CWV_Attribution_Interface {
+    /**
+     * A kiváltó elem selectora: LCP-nél a legnagyobb elem, INP-nél az interakció
+     * célpontja, CLS-nél a legtöbbet elmozduló elem. Ha a `componentPrefixes`
+     * konfigurálva van, komponens-szintű prefix-szel annotálva.
+     */
+    target?: string;
+    /** LCP: erőforrás URL-je (ha az LCP-elem kép). */
+    url?: string;
+    /** LCP fázis / FCP / TTFB: szerver-válaszidő ms. */
+    timeToFirstByte?: number;
+    /** LCP fázis: az LCP-erőforrás betöltés-késleltetése ms. */
+    resourceLoadDelay?: number;
+    /** LCP fázis: az LCP-erőforrás betöltési ideje ms. */
+    resourceLoadDuration?: number;
+    /** LCP fázis: render-késleltetés a betöltés után ms. */
+    elementRenderDelay?: number;
+    /** INP: az interakció típusa (pointer / keyboard). */
+    interactionType?: string;
+    /** INP fázis: input-késleltetés a fő szálon ms. */
+    inputDelay?: number;
+    /** INP fázis: event-handler feldolgozási idő ms (gyakran change-detection). */
+    processingDuration?: number;
+    /** INP fázis: a következő paint megjelenítési késleltetése ms. */
+    presentationDelay?: number;
+    /** CLS: a legnagyobb egyedi layout-shift értéke. */
+    largestShiftValue?: number;
+    /** CLS: a legnagyobb shift időpontja ms. */
+    largestShiftTime?: number;
+}
+//# sourceMappingURL=fdp-cwv-attribution.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-attribution.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-attribution.interface.js.map

package/build/_models/interfaces/fdp-cwv-budgets.interface.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Core Web Vitals budget-küszöbök egy CWV diag-futáshoz.
+ *
+ * A budget NEM a Google standard rating-küszöb (azt a `web-vitals` library adja
+ * `metric.rating`-ben) — ez a MI konfigurálható kapunk: ha egy route metrikája
+ * rosszabb a budgetnél, a route `overBudget`-listájába kerül, és a teljes futás
+ * `status: 'warn'` lesz. POC-ban warn-only (nem blokkol deploy-t).
+ *
+ * Mértékegységek: lcpMs / inpMs milliszekundum, cls dimenzió-nélküli.
+ * Bármelyik mező opcionális — ha nincs megadva, az adott metrikára nincs budget-check.
+ */
+export interface FDP_CWV_Budgets_Interface {
+    /** Largest Contentful Paint felső budget ms-ben (Google "good": 2500). */
+    lcpMs?: number;
+    /** Interaction to Next Paint felső budget ms-ben (Google "good": 200). */
+    inpMs?: number;
+    /** Cumulative Layout Shift felső budget (Google "good": 0.1). */
+    cls?: number;
+}
+//# sourceMappingURL=fdp-cwv-budgets.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-budgets.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-budgets.interface.js.map

package/build/_models/interfaces/fdp-cwv-metric.interface.d.ts

@@ -0,0 +1,17 @@
+import { FDP_CWV_Attribution_Interface } from './fdp-cwv-attribution.interface';
+/**
+ * Egy CWV metrika mért értéke + minősítése + attribution-je.
+ *
+ * A `rating` a `web-vitals` library standard küszöbei szerint ('good' < küszöb1,
+ * 'needs-improvement' < küszöb2, 'poor' afölött). Az `overBudget` (a route-szinten)
+ * a MI konfigurálható budgetünk — a kettő független.
+ */
+export interface FDP_CWV_Metric_Interface {
+    /** A mért érték (LCP/INP/FCP/TTFB ms-ben; CLS dimenzió-nélküli). */
+    value: number;
+    /** web-vitals standard minősítés. */
+    rating: 'good' | 'needs-improvement' | 'poor';
+    /** A kiváltó ok beazonosítása (DOM-elem + fázis-breakdown). */
+    attribution?: FDP_CWV_Attribution_Interface;
+}
+//# sourceMappingURL=fdp-cwv-metric.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-metric.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-metric.interface.js.map

package/build/_models/interfaces/fdp-cwv-raw-metric.interface.d.ts

@@ -0,0 +1,18 @@
+import { FDP_CWV_Attribution_Interface } from './fdp-cwv-attribution.interface';
+/**
+ * Nyers metrika-alak, amit a collector bongeszo-oldali read-fuggvenye visszaad
+ * (mar serializalhato: primitivek + string-ek, nyers PerformanceEntry NELKUL).
+ *
+ * A `FDP_CWV_Collector_Util.buildRouteResult` ezt alakitja tipizalt route-eredmennye.
+ */
+export interface FDP_CWV_RawMetric_Interface {
+    /** Metrika neve: 'LCP' | 'INP' | 'CLS' | 'FCP' | 'TTFB'. */
+    name: string;
+    /** A mert ertek. */
+    value: number;
+    /** web-vitals standard minosites. */
+    rating: 'good' | 'needs-improvement' | 'poor';
+    /** Kiemelt, serializalhato attribution-mezok. */
+    attribution: FDP_CWV_Attribution_Interface;
+}
+//# sourceMappingURL=fdp-cwv-raw-metric.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-raw-metric.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-raw-metric.interface.js.map

package/build/_models/interfaces/fdp-cwv-result.interface.d.ts

@@ -0,0 +1,31 @@
+import { FDP_CWV_RouteResult_Interface } from './fdp-cwv-route-result.interface';
+import { FDP_CWV_Budgets_Interface } from './fdp-cwv-budgets.interface';
+/**
+ * Egy teljes CWV diag-futás eredménye — ez kerül a sidecar JSON-be
+ * (`./logs/cicd-pipeline/diagnostics/cwv-diag.json`), majd a `dc cdp`
+ * report-builder a `cicd-report.json` `diagnostics[].data`-jába emeli.
+ *
+ * `status`: 'ok' ha egyik route sem lépte túl a budgetet, 'warn' ha legalább egy
+ * túllépte. POC-ban a 'warn' NEM blokkolja a pipeline-t (report-only).
+ */
+export interface FDP_CWV_Result_Interface {
+    /** A mérés időpontja ISO-stringként. */
+    collectedAt: string;
+    /** A mért base URL (az első navigáció origin-je). */
+    baseUrl: string;
+    /** Az alkalmazott budgetek (visszajátszáshoz / riporthoz). */
+    budgets?: FDP_CWV_Budgets_Interface;
+    /** Route-onkénti eredmények. */
+    routes: FDP_CWV_RouteResult_Interface[];
+    /** A legrosszabb értékek az összes route-on (trend-projekcióhoz az Overseerben). */
+    worst: {
+        lcpMs?: number;
+        inpMs?: number;
+        cls?: number;
+    };
+    /** Igaz, ha legalább egy route legalább egy metrikája budget fölött van. */
+    anyOverBudget: boolean;
+    /** Összesített státusz: 'ok' | 'warn'. */
+    status: 'ok' | 'warn';
+}
+//# sourceMappingURL=fdp-cwv-result.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-result.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-result.interface.js.map

package/build/_models/interfaces/fdp-cwv-route-config.interface.d.ts

@@ -0,0 +1,26 @@
+import { Page } from '@playwright/test';
+/**
+ * Egy mérendő route konfigurációja a CWV collector-hez.
+ *
+ * A `path` relatív (a Playwright `page.goto` a context `baseURL`-jéhez fűzi), így
+ * ugyanaz a route-lista lokál (`http://localhost:4212`) és deployolt test-env
+ * (`https://test.organizer...`) ellen is használható.
+ *
+ * Az `interact` callback a felelős az INP kiváltásáért: VALÓS Playwright input
+ * (click/type/scroll) kell — szintetikus event-dispatch NEM generál INP-t.
+ */
+export interface FDP_CWV_RouteConfig_Interface {
+    /** Relatív route path, pl. '/landing/login' vagy '/main/home'. */
+    path: string;
+    /** Olvasható címke a riportban; ha hiányzik, a `path` használt. */
+    label?: string;
+    /** Opcionális selector, amire navigáció után várunk (oldal-kész jelzés). */
+    waitForSelector?: string;
+    /**
+     * Opcionális interakció-script az INP méréséhez. VALÓS Playwright input-ot
+     * használjon (pl. `await page.getByRole('button', ...).click()`), különben
+     * az INP üres marad. A flush + olvasás ezután automatikus.
+     */
+    interact?: (page: Page) => Promise<void>;
+}
+//# sourceMappingURL=fdp-cwv-route-config.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-route-config.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-route-config.interface.js.map

package/build/_models/interfaces/fdp-cwv-route-result.interface.d.ts

@@ -0,0 +1,27 @@
+import { FDP_CWV_Metric_Interface } from './fdp-cwv-metric.interface';
+/**
+ * Egy route CWV mérési eredménye.
+ *
+ * Bármelyik metrika hiányozhat: pl. az INP csak akkor van, ha volt valós
+ * interakció; a CLS 0 lehet, ha nincs shift. Az `overBudget` a route azon
+ * metrikáit sorolja fel ('lcp'|'inp'|'cls'), amik a konfigurált budget fölött vannak.
+ */
+export interface FDP_CWV_RouteResult_Interface {
+    /** A route path-je. */
+    route: string;
+    /** Olvasható címke (a config `label`-je vagy a path). */
+    label: string;
+    /** Largest Contentful Paint (ms). */
+    lcp?: FDP_CWV_Metric_Interface;
+    /** Interaction to Next Paint (ms). */
+    inp?: FDP_CWV_Metric_Interface;
+    /** Cumulative Layout Shift (dimenzió-nélküli). */
+    cls?: FDP_CWV_Metric_Interface;
+    /** First Contentful Paint (ms) — diagnosztikai. */
+    fcp?: FDP_CWV_Metric_Interface;
+    /** Time To First Byte (ms) — diagnosztikai. */
+    ttfb?: FDP_CWV_Metric_Interface;
+    /** A budget fölötti metrikák kulcsai, pl. ['lcp','cls']. */
+    overBudget: string[];
+}
+//# sourceMappingURL=fdp-cwv-route-result.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-route-result.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-route-result.interface.js.map

package/build/_models/interfaces/fdp-cwv-run-config.interface.d.ts

@@ -0,0 +1,35 @@
+import { FDP_CWV_RouteConfig_Interface } from './fdp-cwv-route-config.interface';
+import { FDP_CWV_Budgets_Interface } from './fdp-cwv-budgets.interface';
+/**
+ * A `FDP_CWV_Collector_Util.collect()` bemeneti konfigurációja.
+ *
+ * A `webVitalsScript` a `web-vitals/attribution` IIFE-bundle FORRÁSA string-ként.
+ * A shipped fdp-e2e-helpers SZÁNDÉKOSAN nem importálja a web-vitals-t (és nem
+ * használ require-t) — a fogyasztó e2e projekt (ahol a `require.resolve` megengedett)
+ * olvassa be a fájlt és adja át:
+ *
+ *   const wv = fs.readFileSync(require.resolve('web-vitals/dist/web-vitals.attribution.iife.js'), 'utf-8');
+ *
+ * A bundle a böngészőben `window.webVitals`-t definiál (onLCP/onINP/onCLS/onFCP/onTTFB).
+ */
+export interface FDP_CWV_RunConfig_Interface {
+    /** A mérendő route-ok listája (sorrendben). */
+    routes: FDP_CWV_RouteConfig_Interface[];
+    /** A `web-vitals/attribution` IIFE-bundle forrása string-ként (lásd fent). */
+    webVitalsScript: string;
+    /** Opcionális budget-küszöbök; ha hiányzik, nincs budget-check (csak rating). */
+    budgets?: FDP_CWV_Budgets_Interface;
+    /**
+     * FDP komponens-prefixek (pl. ['s-','ad-','m1-','fr-']) az attribution-target
+     * komponens-szintű annotálásához. A `generateTarget` a legközelebbi olyan
+     * ős-elemet keresi, aminek a tag-prefixe ebben a listában van, és azt teszi a
+     * selector elé — így a riport komponens-szinten beszél. Default: csak a natív
+     * web-vitals selector.
+     */
+    componentPrefixes?: string[];
+    /** Várakozás a visibility-flush után ms-ben (a callback-eknek idő kell). Default: 600. */
+    flushTimeoutMs?: number;
+    /** Navigáció timeout ms-ben route-onként. Default: 20000. */
+    navigationTimeoutMs?: number;
+}
+//# sourceMappingURL=fdp-cwv-run-config.interface.d.ts.map

package/build/_models/interfaces/fdp-cwv-run-config.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=fdp-cwv-run-config.interface.js.map

package/build/index.d.ts

@@ -1,9 +1,18 @@
 export * from './_collections/e2e-hard-delete.util';
 export * from './_collections/e2e-unique-generator.util';
+export * from './_collections/fdp-cwv-collector.util';
 export * from './_services/e2e-config.service';
 export * from './_services/e2e-logger.service';
 export * from './_services/e2e-user-manager.service';
 export * from './_models/interfaces/e2e-hard-delete-options.interface';
 export * from './_models/interfaces/e2e-test-config.interface';
 export * from './_models/interfaces/e2e-user.interface';
+export * from './_models/interfaces/fdp-cwv-run-config.interface';
+export * from './_models/interfaces/fdp-cwv-route-config.interface';
+export * from './_models/interfaces/fdp-cwv-budgets.interface';
+export * from './_models/interfaces/fdp-cwv-result.interface';
+export * from './_models/interfaces/fdp-cwv-route-result.interface';
+export * from './_models/interfaces/fdp-cwv-metric.interface';
+export * from './_models/interfaces/fdp-cwv-attribution.interface';
+export * from './_models/interfaces/fdp-cwv-raw-metric.interface';
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -4,6 +4,7 @@ const tslib_1 = require("tslib");
 // COLLECTIONS / UTILS
 tslib_1.__exportStar(require("./_collections/e2e-hard-delete.util"), exports);
 tslib_1.__exportStar(require("./_collections/e2e-unique-generator.util"), exports);
+tslib_1.__exportStar(require("./_collections/fdp-cwv-collector.util"), exports);
 // SERVICES
 tslib_1.__exportStar(require("./_services/e2e-config.service"), exports);
 tslib_1.__exportStar(require("./_services/e2e-logger.service"), exports);
@@ -12,4 +13,12 @@ tslib_1.__exportStar(require("./_services/e2e-user-manager.service"), exports);
 tslib_1.__exportStar(require("./_models/interfaces/e2e-hard-delete-options.interface"), exports);
 tslib_1.__exportStar(require("./_models/interfaces/e2e-test-config.interface"), exports);
 tslib_1.__exportStar(require("./_models/interfaces/e2e-user.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-run-config.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-route-config.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-budgets.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-result.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-route-result.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-metric.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-attribution.interface"), exports);
+tslib_1.__exportStar(require("./_models/interfaces/fdp-cwv-raw-metric.interface"), exports);
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/fdp-e2e-helpers",
-  "version": "01.15.10",
+  "version": "01.15.14",
   "description": "Shared E2E test helpers for FDP-stack apps. First util: E2E_HardDelete_Util. Stateless utility-collection — NOT a framework.",
   "DyBu_settings": {
     "packageType": "shared-package",
@@ -70,8 +70,9 @@
     "HOWTO.md"
   ],
   "peerDependencies": {
-    "@futdevpro/fsm-dynamo": ">=1.15.0",
-    "@futdevpro/nts-dynamo": ">=1.15.0"
+    "@futdevpro/fsm-dynamo": "1.15.16",
+    "@futdevpro/nts-dynamo": "1.15.34",
+    "@playwright/test": ">=1.49.0"
   },
   "dependencies": {
     "axios": "~1.8.1",
@@ -80,8 +81,9 @@
   },
   "devDependencies": {
     "@futdevpro/dynamo-eslint": "1.15.10",
-    "@futdevpro/fsm-dynamo": "1.15.13",
-    "@futdevpro/nts-dynamo": "1.15.31",
+    "@futdevpro/fsm-dynamo": "1.15.16",
+    "@futdevpro/nts-dynamo": "1.15.34",
+    "@playwright/test": "^1.49.0",
     "@types/jasmine": "^5.1.5",
     "@typescript-eslint/eslint-plugin": "^8.41.0",
     "@typescript-eslint/parser": "^8.41.0",