@rickcedwhat/playwright-smart-table 6.7.0 → 6.7.3

package/dist/useTable.js

@@ -33,6 +33,7 @@ const tableMapper_1 = require("./engine/tableMapper");
 const rowFinder_1 = require("./engine/rowFinder");
 const debugUtils_1 = require("./utils/debugUtils");
 const smartRowArray_1 = require("./utils/smartRowArray");
+const elementTracker_1 = require("./utils/elementTracker");
 /**
  * Main hook to interact with a table.
  */
@@ -121,9 +122,24 @@ const useTable = (rootLocator, configOptions = {}) => {
         console.log(`⚠️ Throwing error to display [${promptName}] cleanly...`);
         throw new Error(finalPrompt);
     });
-    const _ensureInitialized = () => __awaiter(void 0, void 0, void 0, function* () {
+    const _autoInit = () => __awaiter(void 0, void 0, void 0, function* () {
         yield tableMapper.getMap();
     });
+    const _advancePage = () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const context = { root: rootLocator, config, page: rootLocator.page(), resolve, getHeaderCell: result.getHeaderCell, getHeaders: result.getHeaders, scrollToColumn: result.scrollToColumn };
+        let advanced;
+        if (typeof config.strategies.pagination === 'function') {
+            advanced = !!(yield config.strategies.pagination(context));
+        }
+        else {
+            advanced = !!(((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.goNext) && (yield config.strategies.pagination.goNext(context)));
+        }
+        if (advanced) {
+            tableState.currentPageIndex++;
+        }
+        return advanced;
+    });
     const result = {
         get currentPageIndex() { return tableState.currentPageIndex; },
         set currentPageIndex(v) { tableState.currentPageIndex = v; },
@@ -160,7 +176,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         reset: () => __awaiter(void 0, void 0, void 0, function* () {
             var _a;
             log("Resetting table...");
-            const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
+            const context = { root: rootLocator, config, page: rootLocator.page(), resolve, getHeaderCell: result.getHeaderCell };
             yield config.onReset(context);
             if (typeof config.strategies.pagination !== 'function' && ((_a = config.strategies.pagination) === null || _a === void 0 ? void 0 : _a.goToFirst)) {
                 log("Auto-navigating to first page...");
@@ -172,7 +188,8 @@ const useTable = (rootLocator, configOptions = {}) => {
             _hasPaginated = false;
             tableState.currentPageIndex = 0;
             tableMapper.clear();
-            log("Table reset complete.");
+            log("Table reset complete. Calling autoInit to restore state.");
+            yield _autoInit();
         }),
         revalidate: () => __awaiter(void 0, void 0, void 0, function* () {
             log("Revalidating table structure...");
@@ -182,16 +199,16 @@ const useTable = (rootLocator, configOptions = {}) => {
         getRow: (filters, options = { exact: false }) => {
             const map = tableMapper.getMapSync();
             if (!map)
-                throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.getRows() which auto-initialize.');
+                throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.findRows() which auto-initialize.');
             const allRows = resolve(config.rowSelector, rootLocator);
             const matchedRows = filterEngine.applyFilters(allRows, filters, map, options.exact || false, rootLocator.page());
             const rowLocator = matchedRows.first();
             return _makeSmart(rowLocator, map, 0); // fallback index 0
         },
-        getRowByIndex: (index, options = {}) => {
+        getRowByIndex: (index) => {
             const map = tableMapper.getMapSync();
             if (!map)
-                throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.getRows() which auto-initialize.');
+                throw new Error('Table not initialized. Call await table.init() first, or use async methods like table.findRow() or table.findRows() which auto-initialize.');
             const rowLocator = resolve(config.rowSelector, rootLocator).nth(index);
             return _makeSmart(rowLocator, map, index);
         },
@@ -208,7 +225,7 @@ const useTable = (rootLocator, configOptions = {}) => {
         sorting: {
             apply: (columnName, direction) => __awaiter(void 0, void 0, void 0, function* () {
                 var _a;
-                yield _ensureInitialized();
+                yield _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
                 log(`Applying sort for column "${columnName}" (${direction})`);
@@ -237,7 +254,7 @@ const useTable = (rootLocator, configOptions = {}) => {
                 throw new Error(`Failed to sort column "${columnName}" to "${direction}" after ${maxRetries} attempts.`);
             }),
             getState: (columnName) => __awaiter(void 0, void 0, void 0, function* () {
-                yield _ensureInitialized();
+                yield _autoInit();
                 if (!config.strategies.sorting)
                     throw new Error('No sorting strategy has been configured.');
                 const context = { root: rootLocator, config, page: rootLocator.page(), resolve, getHeaderCell: result.getHeaderCell };
@@ -247,216 +264,211 @@ const useTable = (rootLocator, configOptions = {}) => {
         // ─── Shared async row iterator ───────────────────────────────────────────
         [Symbol.asyncIterator]() {
             return __asyncGenerator(this, arguments, function* _a() {
-                var _b;
-                yield __await(_ensureInitialized());
+                yield __await(_autoInit());
                 const map = tableMapper.getMapSync();
                 const effectiveMaxPages = config.maxPages;
-                let rowIndex = 0;
-                let pagesScanned = 1;
-                while (true) {
-                    const pageRows = yield __await(resolve(config.rowSelector, rootLocator).all());
-                    for (const rowLocator of pageRows) {
-                        yield yield __await({ row: _makeSmart(rowLocator, map, rowIndex), rowIndex });
-                        rowIndex++;
-                    }
-                    if (pagesScanned >= effectiveMaxPages)
-                        break;
-                    const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
-                    let advanced;
-                    if (typeof config.strategies.pagination === 'function') {
-                        advanced = !!(yield __await(config.strategies.pagination(context)));
-                    }
-                    else {
-                        advanced = !!(((_b = config.strategies.pagination) === null || _b === void 0 ? void 0 : _b.goNext) && (yield __await(config.strategies.pagination.goNext(context))));
+                const tracker = new elementTracker_1.ElementTracker('iterator');
+                try {
+                    let rowIndex = 0;
+                    let pagesScanned = 1;
+                    while (true) {
+                        const rowLocators = resolve(config.rowSelector, rootLocator);
+                        const newIndices = yield __await(tracker.getUnseenIndices(rowLocators));
+                        const pageRows = yield __await(rowLocators.all());
+                        for (const idx of newIndices) {
+                            yield yield __await({ row: _makeSmart(pageRows[idx], map, rowIndex), rowIndex });
+                            rowIndex++;
+                        }
+                        if (pagesScanned >= effectiveMaxPages)
+                            break;
+                        if (!(yield __await(_advancePage())))
+                            break;
+                        pagesScanned++;
                     }
-                    if (!advanced)
-                        break;
-                    tableState.currentPageIndex++;
-                    pagesScanned++;
+                }
+                finally {
+                    yield __await(tracker.cleanup(rootLocator.page()));
                 }
             });
         },
         // ─── Private row-iteration engine ────────────────────────────────────────
         forEach: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            var _a, _b, _c, _d;
-            yield _ensureInitialized();
+            var _a, _b, _c;
+            yield _autoInit();
             const map = tableMapper.getMapSync();
             const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
             const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : config.strategies.dedupe;
             const dedupeKeys = dedupeStrategy ? new Set() : null;
             const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
-            let rowIndex = 0;
-            let stopped = false;
-            let pagesScanned = 1;
-            const stop = () => { stopped = true; };
-            while (!stopped) {
-                const pageRows = yield resolve(config.rowSelector, rootLocator).all();
-                const smartRows = pageRows.map((r, i) => _makeSmart(r, map, rowIndex + i));
-                if (parallel) {
-                    yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
-                        if (stopped)
-                            return;
-                        if (dedupeKeys) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key))
+            const tracker = new elementTracker_1.ElementTracker('forEach');
+            try {
+                let rowIndex = 0;
+                let stopped = false;
+                let pagesScanned = 1;
+                const stop = () => { stopped = true; };
+                while (!stopped) {
+                    const rowLocators = resolve(config.rowSelector, rootLocator);
+                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                    const pageRows = yield rowLocators.all();
+                    const smartRows = newIndices.map((idx, i) => _makeSmart(pageRows[idx], map, rowIndex + i));
+                    if (parallel) {
+                        yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
+                            if (stopped)
                                 return;
-                            dedupeKeys.add(key);
-                        }
-                        yield callback({ row, rowIndex: row.rowIndex, stop });
-                    })));
-                }
-                else {
-                    for (const row of smartRows) {
-                        if (stopped)
-                            break;
-                        if (dedupeKeys) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key))
-                                continue;
-                            dedupeKeys.add(key);
+                            if (dedupeKeys) {
+                                const key = yield dedupeStrategy(row);
+                                if (dedupeKeys.has(key))
+                                    return;
+                                dedupeKeys.add(key);
+                            }
+                            yield callback({ row, rowIndex: row.rowIndex, stop });
+                        })));
+                    }
+                    else {
+                        for (const row of smartRows) {
+                            if (stopped)
+                                break;
+                            if (dedupeKeys) {
+                                const key = yield dedupeStrategy(row);
+                                if (dedupeKeys.has(key))
+                                    continue;
+                                dedupeKeys.add(key);
+                            }
+                            yield callback({ row, rowIndex: row.rowIndex, stop });
                         }
-                        yield callback({ row, rowIndex: row.rowIndex, stop });
                     }
+                    rowIndex += smartRows.length;
+                    if (stopped || pagesScanned >= effectiveMaxPages)
+                        break;
+                    if (!(yield _advancePage()))
+                        break;
+                    pagesScanned++;
                 }
-                rowIndex += smartRows.length;
-                if (stopped || pagesScanned >= effectiveMaxPages)
-                    break;
-                const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
-                let advanced;
-                if (typeof config.strategies.pagination === 'function') {
-                    advanced = !!(yield config.strategies.pagination(context));
-                }
-                else {
-                    advanced = !!(((_d = config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) && (yield config.strategies.pagination.goNext(context)));
-                }
-                if (!advanced)
-                    break;
-                tableState.currentPageIndex++;
-                pagesScanned++;
+            }
+            finally {
+                yield tracker.cleanup(rootLocator.page());
             }
         }),
         map: (callback_1, ...args_1) => __awaiter(void 0, [callback_1, ...args_1], void 0, function* (callback, options = {}) {
-            var _a, _b, _c, _d;
-            yield _ensureInitialized();
+            var _a, _b, _c;
+            yield _autoInit();
             const map = tableMapper.getMapSync();
             const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
             const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : config.strategies.dedupe;
             const dedupeKeys = dedupeStrategy ? new Set() : null;
             const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : true;
+            const tracker = new elementTracker_1.ElementTracker('map');
             const results = [];
-            let rowIndex = 0;
-            let stopped = false;
-            let pagesScanned = 1;
-            const stop = () => { stopped = true; };
-            while (!stopped) {
-                const pageRows = yield resolve(config.rowSelector, rootLocator).all();
-                const smartRows = pageRows.map((r, i) => _makeSmart(r, map, rowIndex + i));
-                if (parallel) {
-                    const SKIP = Symbol('skip');
-                    const pageResults = yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
-                        if (dedupeKeys) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key))
-                                return SKIP;
-                            dedupeKeys.add(key);
+            try {
+                let rowIndex = 0;
+                let stopped = false;
+                let pagesScanned = 1;
+                const stop = () => { stopped = true; };
+                while (!stopped) {
+                    const rowLocators = resolve(config.rowSelector, rootLocator);
+                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                    const pageRows = yield rowLocators.all();
+                    const smartRows = newIndices.map((idx, i) => _makeSmart(pageRows[idx], map, rowIndex + i));
+                    if (parallel) {
+                        const SKIP = Symbol('skip');
+                        const pageResults = yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
+                            if (dedupeKeys) {
+                                const key = yield dedupeStrategy(row);
+                                if (dedupeKeys.has(key))
+                                    return SKIP;
+                                dedupeKeys.add(key);
+                            }
+                            return callback({ row, rowIndex: row.rowIndex, stop });
+                        })));
+                        for (const r of pageResults) {
+                            if (r !== SKIP)
+                                results.push(r);
                         }
-                        return callback({ row, rowIndex: row.rowIndex, stop });
-                    })));
-                    for (const r of pageResults) {
-                        if (r !== SKIP)
-                            results.push(r);
                     }
-                }
-                else {
-                    for (const row of smartRows) {
-                        if (stopped)
-                            break;
-                        if (dedupeKeys) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key))
-                                continue;
-                            dedupeKeys.add(key);
+                    else {
+                        for (const row of smartRows) {
+                            if (stopped)
+                                break;
+                            if (dedupeKeys) {
+                                const key = yield dedupeStrategy(row);
+                                if (dedupeKeys.has(key))
+                                    continue;
+                                dedupeKeys.add(key);
+                            }
+                            results.push(yield callback({ row, rowIndex: row.rowIndex, stop }));
                         }
-                        results.push(yield callback({ row, rowIndex: row.rowIndex, stop }));
                     }
+                    rowIndex += smartRows.length;
+                    if (stopped || pagesScanned >= effectiveMaxPages)
+                        break;
+                    if (!(yield _advancePage()))
+                        break;
+                    pagesScanned++;
                 }
-                rowIndex += smartRows.length;
-                if (stopped || pagesScanned >= effectiveMaxPages)
-                    break;
-                const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
-                let advanced;
-                if (typeof config.strategies.pagination === 'function') {
-                    advanced = !!(yield config.strategies.pagination(context));
-                }
-                else {
-                    advanced = !!(((_d = config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) && (yield config.strategies.pagination.goNext(context)));
-                }
-                if (!advanced)
-                    break;
-                tableState.currentPageIndex++;
-                pagesScanned++;
+            }
+            finally {
+                yield tracker.cleanup(rootLocator.page());
             }
             return results;
         }),
         filter: (predicate_1, ...args_1) => __awaiter(void 0, [predicate_1, ...args_1], void 0, function* (predicate, options = {}) {
-            var _a, _b, _c, _d;
-            yield _ensureInitialized();
+            var _a, _b, _c;
+            yield _autoInit();
             const map = tableMapper.getMapSync();
             const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : config.maxPages;
             const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : config.strategies.dedupe;
             const dedupeKeys = dedupeStrategy ? new Set() : null;
             const parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
+            const tracker = new elementTracker_1.ElementTracker('filter');
             const matched = [];
-            let rowIndex = 0;
-            let stopped = false;
-            let pagesScanned = 1;
-            const stop = () => { stopped = true; };
-            while (!stopped) {
-                const pageRows = yield resolve(config.rowSelector, rootLocator).all();
-                const smartRows = pageRows.map((r, i) => _makeSmart(r, map, rowIndex + i, pagesScanned - 1));
-                if (parallel) {
-                    const flags = yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
-                        if (dedupeKeys) {
-                            const key = yield dedupeStrategy(row);
-                            if (dedupeKeys.has(key))
-                                return false;
-                            dedupeKeys.add(key);
-                        }
-                        return predicate({ row, rowIndex: row.rowIndex, stop });
-                    })));
-                    smartRows.forEach((row, i) => { if (flags[i])
-                        matched.push(row); });
-                }
-                else {
-                    for (const row of smartRows) {
-                        if (stopped)
-                            break;
-                        if (dedupeKeys) {
-                            const key = yield options.dedupe(row);
-                            if (dedupeKeys.has(key))
-                                continue;
-                            dedupeKeys.add(key);
-                        }
-                        if (yield predicate({ row, rowIndex: row.rowIndex, stop })) {
-                            matched.push(row);
+            try {
+                let rowIndex = 0;
+                let stopped = false;
+                let pagesScanned = 1;
+                const stop = () => { stopped = true; };
+                while (!stopped) {
+                    const rowLocators = resolve(config.rowSelector, rootLocator);
+                    const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                    const pageRows = yield rowLocators.all();
+                    const smartRows = newIndices.map((idx, i) => _makeSmart(pageRows[idx], map, rowIndex + i, pagesScanned - 1));
+                    if (parallel) {
+                        const flags = yield Promise.all(smartRows.map((row) => __awaiter(void 0, void 0, void 0, function* () {
+                            if (dedupeKeys) {
+                                const key = yield dedupeStrategy(row);
+                                if (dedupeKeys.has(key))
+                                    return false;
+                                dedupeKeys.add(key);
+                            }
+                            return predicate({ row, rowIndex: row.rowIndex, stop });
+                        })));
+                        smartRows.forEach((row, i) => { if (flags[i])
+                            matched.push(row); });
+                    }
+                    else {
+                        for (const row of smartRows) {
+                            if (stopped)
+                                break;
+                            if (dedupeKeys) {
+                                const key = yield dedupeStrategy(row);
+                                if (dedupeKeys.has(key))
+                                    continue;
+                                dedupeKeys.add(key);
+                            }
+                            if (yield predicate({ row, rowIndex: row.rowIndex, stop })) {
+                                matched.push(row);
+                            }
                         }
                     }
+                    rowIndex += smartRows.length;
+                    if (stopped || pagesScanned >= effectiveMaxPages)
+                        break;
+                    if (!(yield _advancePage()))
+                        break;
+                    pagesScanned++;
                 }
-                rowIndex += smartRows.length;
-                if (stopped || pagesScanned >= effectiveMaxPages)
-                    break;
-                const context = { root: rootLocator, config, page: rootLocator.page(), resolve };
-                let advanced;
-                if (typeof config.strategies.pagination === 'function') {
-                    advanced = !!(yield config.strategies.pagination(context));
-                }
-                else {
-                    advanced = !!(((_d = config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) && (yield config.strategies.pagination.goNext(context)));
-                }
-                if (!advanced)
-                    break;
-                tableState.currentPageIndex++;
-                pagesScanned++;
+            }
+            finally {
+                yield tracker.cleanup(rootLocator.page());
             }
             return (0, smartRowArray_1.createSmartRowArray)(matched);
         }),

package/dist/utils/elementTracker.d.ts

@@ -0,0 +1,15 @@
+import { Locator } from '@playwright/test';
+export declare class ElementTracker {
+    readonly id: string;
+    constructor(prefix?: string);
+    /**
+     * Finds the indices of newly seen elements in the browser, storing their text signature
+     * in a WeakMap. This gracefully handles both append-only DOMs (by identity) and
+     * virtualized DOMs (by text signature if nodes are recycled).
+     */
+    getUnseenIndices(locators: Locator): Promise<number[]>;
+    /**
+     * Cleans up the tracking map from the browser window object.
+     */
+    cleanup(page: any): Promise<void>;
+}

package/dist/utils/elementTracker.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementTracker = void 0;
+class ElementTracker {
+    constructor(prefix = 'tracker') {
+        this.id = `__smartTable_${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Finds the indices of newly seen elements in the browser, storing their text signature
+     * in a WeakMap. This gracefully handles both append-only DOMs (by identity) and
+     * virtualized DOMs (by text signature if nodes are recycled).
+     */
+    getUnseenIndices(locators) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield locators.evaluateAll((elements, trackerId) => {
+                const win = window;
+                if (!win[trackerId]) {
+                    win[trackerId] = new WeakMap();
+                }
+                const seenMap = win[trackerId];
+                const newIndices = [];
+                elements.forEach((el, index) => {
+                    // Determine a lightweight signature for the row (textContent strips HTML, fast)
+                    const signature = el.textContent || '';
+                    // If it's a new element, OR a recycled element with new data
+                    if (seenMap.get(el) !== signature) {
+                        seenMap.set(el, signature);
+                        newIndices.push(index);
+                    }
+                });
+                return newIndices;
+            }, this.id);
+        });
+    }
+    /**
+     * Cleans up the tracking map from the browser window object.
+     */
+    cleanup(page) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield page.evaluate((trackerId) => {
+                    delete window[trackerId];
+                }, this.id);
+            }
+            catch (e) {
+                // Ignore context destroyed errors during cleanup
+            }
+        });
+    }
+}
+exports.ElementTracker = ElementTracker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rickcedwhat/playwright-smart-table",
-  "version": "6.7.0",
+  "version": "6.7.3",
   "description": "Smart, column-aware table interactions for Playwright",
   "author": "Cedrick Catalan",
   "license": "MIT",
@@ -23,11 +23,16 @@
     "docs:build": "vitepress build docs",
     "build": "npm run generate-types && npm run generate-config-types && npm run generate-docs && npm run generate-all-api-docs && npm run update-all-api-signatures && tsc",
     "prepublishOnly": "npm run build",
+    "clean-port": "lsof -ti:3000 | xargs kill -9 || true",
+    "pretest": "npm run clean-port",
+    "posttest": "npm run clean-port",
     "test": "npm run test:unit && npx playwright test",
     "test:unit": "vitest run --reporter=verbose --reporter=html",
     "test:unit:ui": "vitest --ui",
+    "pretest:e2e": "npm run clean-port",
+    "posttest:e2e": "npm run clean-port",
     "test:e2e": "npx playwright test",
-    "test:compatibility": "npx playwright test compatibility",
+    "test:compatibility": "npm run clean-port && npx playwright test compatibility",
     "prepare": "husky install"
   },
   "keywords": [