@rickcedwhat/playwright-smart-table 6.9.0 → 6.10.1

package/dist/engine/tableIteration.js

@@ -1,13 +1,4 @@
 "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.runForEach = runForEach;
 exports.runMap = runMap;
@@ -21,134 +12,128 @@ function log(config, msg) {
 }
 const SKIP = Symbol('skip');
 /** Delegates to {@link runMap}; void results are discarded. */
-function runForEach(env_1, callback_1) {
-    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}) {
-        yield runMap(env, callback, options, 'forEach');
-    });
+async function runForEach(env, callback, options = {}) {
+    await runMap(env, callback, options, 'forEach');
 }
 /**
  * Row iteration for map (and forEach/filter via label).
  * Concurrency: `parallel` | `synchronized` | `sequential` (see RowIterationOptions).
  */
-function runMap(env_1, callback_1) {
-    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}, label = 'map') {
-        var _a, _b, _c, _d, _e;
-        const map = env.getMap();
-        const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
-        const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
-        const dedupeKeys = dedupeStrategy ? new Set() : null;
-        const defaultMode = label === 'map' ? 'parallel' : 'sequential';
-        const concurrency = (_d = (_c = options.concurrency) !== null && _c !== void 0 ? _c : env.config.concurrency) !== null && _d !== void 0 ? _d : defaultMode;
-        const useBarrier = concurrency !== 'sequential';
-        // Mutex must not pair with the navigation barrier: synchronized mode needs every row
-        // to enter barrier.sync concurrently; serializing callbacks here deadlocks (first row waits
-        // for batchSize peers that never reach the barrier).
-        const useMutex = concurrency === 'sequential';
-        const useBulk = (_e = options.useBulkPagination) !== null && _e !== void 0 ? _e : false;
-        const tracker = new elementTracker_1.ElementTracker(label);
-        log(env.config, `${label}: starting (maxPages=${effectiveMaxPages}, mode=${concurrency}, dedupe=${!!dedupeStrategy})`);
-        const results = [];
-        try {
-            let rowIndex = 0;
-            let stopped = false;
-            let stoppedIndex = Infinity;
-            let pagesScanned = 1;
-            const stop = (idx) => {
-                if (!stopped) {
-                    log(env.config, `${label}: stop() called at row ${idx} — halting`);
-                    stopped = true;
-                    stoppedIndex = idx;
-                }
-            };
-            while (!stopped) {
-                const rowLocators = env.getRowLocators();
-                const newIndices = yield tracker.getUnseenIndices(rowLocators);
-                const pageRows = yield rowLocators.all();
-                const batchSize = newIndices.length;
-                if (batchSize === 0) {
-                    log(env.config, `${label}: page ${pagesScanned} — no new row(s) found`);
-                }
-                else {
-                    log(env.config, `${label}: scanning page ${pagesScanned} — ${batchSize} new row(s)`);
-                    const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(batchSize) : undefined;
-                    const actionMutex = useMutex ? new mutex_1.Mutex() : null;
-                    const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, pagesScanned - 1, barrier));
-                    const processRow = (row) => __awaiter(this, void 0, void 0, function* () {
-                        try {
-                            if (stopped && row.rowIndex > stoppedIndex) {
+async function runMap(env, callback, options = {}, label = 'map') {
+    var _a, _b, _c, _d, _e;
+    const map = env.getMap();
+    const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : env.config.maxPages;
+    const dedupeStrategy = (_b = options.dedupe) !== null && _b !== void 0 ? _b : env.config.strategies.dedupe;
+    const dedupeKeys = dedupeStrategy ? new Set() : null;
+    const defaultMode = label === 'map' ? 'parallel' : 'sequential';
+    const concurrency = (_d = (_c = options.concurrency) !== null && _c !== void 0 ? _c : env.config.concurrency) !== null && _d !== void 0 ? _d : defaultMode;
+    const useBarrier = concurrency !== 'sequential';
+    // Mutex must not pair with the navigation barrier: synchronized mode needs every row
+    // to enter barrier.sync concurrently; serializing callbacks here deadlocks (first row waits
+    // for batchSize peers that never reach the barrier).
+    const useMutex = concurrency === 'sequential';
+    const useBulk = (_e = options.useBulkPagination) !== null && _e !== void 0 ? _e : false;
+    const tracker = new elementTracker_1.ElementTracker(label);
+    log(env.config, `${label}: starting (maxPages=${effectiveMaxPages}, mode=${concurrency}, dedupe=${!!dedupeStrategy})`);
+    const results = [];
+    try {
+        let rowIndex = 0;
+        let stopped = false;
+        let stoppedIndex = Infinity;
+        let pagesScanned = 1;
+        const stop = (idx) => {
+            if (!stopped) {
+                log(env.config, `${label}: stop() called at row ${idx} — halting`);
+                stopped = true;
+                stoppedIndex = idx;
+            }
+        };
+        while (!stopped) {
+            const rowLocators = env.getRowLocators();
+            const newIndices = await tracker.getUnseenIndices(rowLocators);
+            const pageRows = await rowLocators.all();
+            const batchSize = newIndices.length;
+            if (batchSize === 0) {
+                log(env.config, `${label}: page ${pagesScanned} — no new row(s) found`);
+            }
+            else {
+                log(env.config, `${label}: scanning page ${pagesScanned} — ${batchSize} new row(s)`);
+                const barrier = useBarrier ? new navigationBarrier_1.NavigationBarrier(batchSize) : undefined;
+                const actionMutex = useMutex ? new mutex_1.Mutex() : null;
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, pagesScanned - 1, barrier));
+                const processRow = async (row) => {
+                    try {
+                        if (stopped && row.rowIndex > stoppedIndex) {
+                            return SKIP;
+                        }
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = await dedupeStrategy(row);
+                            if (dedupeKeys.has(key)) {
+                                log(env.config, `${label}: dedupe skip key="${key}"`);
                                 return SKIP;
                             }
-                            if (dedupeKeys && dedupeStrategy) {
-                                const key = yield dedupeStrategy(row);
-                                if (dedupeKeys.has(key)) {
-                                    log(env.config, `${label}: dedupe skip key="${key}"`);
-                                    return SKIP;
-                                }
-                                dedupeKeys.add(key);
-                            }
-                            // Execute callback (optionally serialized via mutex)
-                            const runCallback = () => __awaiter(this, void 0, void 0, function* () {
-                                if (stopped && row.rowIndex > stoppedIndex)
-                                    return SKIP;
-                                log(env.config, `${label}: processing row ${row.rowIndex}`);
-                                return yield callback({ row, rowIndex: row.rowIndex, stop: () => stop(row.rowIndex) });
-                            });
-                            if (actionMutex) {
-                                return yield actionMutex.run(runCallback);
-                            }
-                            else {
-                                return yield runCallback();
-                            }
+                            dedupeKeys.add(key);
                         }
-                        finally {
-                            // Ensure the barrier is notified once per row, even on error or skip.
-                            barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
+                        // Execute callback (optionally serialized via mutex)
+                        const runCallback = async () => {
+                            if (stopped && row.rowIndex > stoppedIndex)
+                                return SKIP;
+                            log(env.config, `${label}: processing row ${row.rowIndex}`);
+                            return await callback({ row, rowIndex: row.rowIndex, stop: () => stop(row.rowIndex) });
+                        };
+                        if (actionMutex) {
+                            return await actionMutex.run(runCallback);
                         }
-                    });
-                    const pageResults = [];
-                    if (concurrency === 'sequential') {
-                        for (const row of smartRows) {
-                            pageResults.push(yield processRow(row));
+                        else {
+                            return await runCallback();
                         }
                     }
-                    else {
-                        const results = yield Promise.all(smartRows.map(processRow));
-                        pageResults.push(...results);
+                    finally {
+                        // Ensure the barrier is notified once per row, even on error or skip.
+                        barrier === null || barrier === void 0 ? void 0 : barrier.markFinished();
                     }
-                    for (let i = 0; i < pageResults.length; i++) {
-                        if (smartRows[i].rowIndex > stoppedIndex)
-                            break;
-                        const r = pageResults[i];
-                        if (r !== SKIP)
-                            results.push(r);
+                };
+                const pageResults = [];
+                if (concurrency === 'sequential') {
+                    for (const row of smartRows) {
+                        pageResults.push(await processRow(row));
                     }
-                    rowIndex += batchSize;
                 }
-                if (stopped || pagesScanned >= effectiveMaxPages)
-                    break;
-                log(env.config, `${label}: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
-                if (!(yield env.advancePage(useBulk))) {
-                    log(env.config, `${label}: no more pages — done`);
-                    break;
+                else {
+                    const results = await Promise.all(smartRows.map(processRow));
+                    pageResults.push(...results);
                 }
-                pagesScanned++;
+                for (let i = 0; i < pageResults.length; i++) {
+                    if (smartRows[i].rowIndex > stoppedIndex)
+                        break;
+                    const r = pageResults[i];
+                    if (r !== SKIP)
+                        results.push(r);
+                }
+                rowIndex += batchSize;
             }
-            log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
-        }
-        finally {
-            yield tracker.cleanup(env.getPage());
+            if (stopped || pagesScanned >= effectiveMaxPages)
+                break;
+            log(env.config, `${label}: advancing to next page (${pagesScanned} → ${pagesScanned + 1})`);
+            if (!await env.advancePage(useBulk)) {
+                log(env.config, `${label}: no more pages — done`);
+                break;
+            }
+            pagesScanned++;
         }
-        return results;
-    });
+        log(env.config, `${label}: complete — ${results.length} result(s) across ${pagesScanned} page(s)`);
+    }
+    finally {
+        await tracker.cleanup(env.getPage());
+    }
+    return results;
 }
 /** Filter via map; returns matched rows as {@link SmartRowArray}. */
-function runFilter(env_1, predicate_1) {
-    return __awaiter(this, arguments, void 0, function* (env, predicate, options = {}) {
-        const mapCallback = (ctx) => __awaiter(this, void 0, void 0, function* () {
-            const matched = yield predicate(ctx);
-            return matched ? ctx.row : SKIP;
-        });
-        const results = yield runMap(env, mapCallback, options, 'filter');
-        return env.createSmartRowArray(results);
-    });
+async function runFilter(env, predicate, options = {}) {
+    const mapCallback = async (ctx) => {
+        const matched = await predicate(ctx);
+        return matched ? ctx.row : SKIP;
+    };
+    const results = await runMap(env, mapCallback, options, 'filter');
+    return env.createSmartRowArray(results);
 }

package/dist/engine/tableMapper.js

@@ -1,13 +1,4 @@
 "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.TableMapper = void 0;
 const headers_1 = require("../strategies/headers");
@@ -22,69 +13,65 @@ class TableMapper {
     log(msg) {
         (0, debugUtils_1.logDebug)(this.config, 'verbose', msg);
     }
-    getMap(timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this._headerMap)
-                return this._headerMap;
-            this.log('Mapping headers...');
-            const headerTimeout = timeout !== null && timeout !== void 0 ? timeout : 3000;
-            const startTime = Date.now();
-            if (this.config.autoScroll) {
-                try {
-                    yield this.rootLocator.scrollIntoViewIfNeeded({ timeout: 1000 });
-                }
-                catch (e) { }
+    async getMap(timeout) {
+        var _a;
+        if (this._headerMap)
+            return this._headerMap;
+        this.log('Mapping headers...');
+        const headerTimeout = timeout !== null && timeout !== void 0 ? timeout : 3000;
+        const startTime = Date.now();
+        if (this.config.autoScroll) {
+            try {
+                await this.rootLocator.scrollIntoViewIfNeeded({ timeout: 1000 });
             }
-            const headerLoc = this.resolve(this.config.headerSelector, this.rootLocator);
-            const strategy = this.config.strategies.header || headers_1.HeaderStrategies.visible;
-            const context = {
-                root: this.rootLocator,
-                config: this.config,
-                page: this.rootLocator.page(),
-                resolve: this.resolve
-            };
-            let lastError = null;
-            while (Date.now() - startTime < headerTimeout) {
-                // 1. Wait for visibility
-                try {
-                    yield headerLoc.first().waitFor({ state: 'visible', timeout: 200 });
-                }
-                catch (e) {
-                    // Continue to check existing/loading state even if not strictly "visible" yet
-                }
-                // 2. Check Smart Loading State
-                if ((_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isHeaderLoading) {
-                    const isStable = !(yield this.config.strategies.loading.isHeaderLoading(context));
-                    if (!isStable) {
-                        this.log('Headers are loading/unstable... waiting');
-                        yield new Promise(r => setTimeout(r, 100));
-                        continue;
-                    }
-                }
-                // 3. Attempt Scan
-                try {
-                    const rawHeaders = yield strategy(context);
-                    const entries = yield this.processHeaders(rawHeaders);
-                    // Success
-                    this._headerMap = new Map(entries);
-                    this.log(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
-                    return this._headerMap;
-                }
-                catch (e) {
-                    lastError = e;
-                    this.log(`Header mapping failed. Attempt ${Math.floor((Date.now() - startTime) / 100)}: ${e.message}`);
-                    yield new Promise(r => setTimeout(r, 100));
+            catch (e) { }
+        }
+        const headerLoc = this.resolve(this.config.headerSelector, this.rootLocator);
+        const strategy = this.config.strategies.header || headers_1.HeaderStrategies.visible;
+        const context = {
+            root: this.rootLocator,
+            config: this.config,
+            page: this.rootLocator.page(),
+            resolve: this.resolve
+        };
+        let lastError = null;
+        while (Date.now() - startTime < headerTimeout) {
+            // 1. Wait for visibility
+            try {
+                await headerLoc.first().waitFor({ state: 'visible', timeout: 200 });
+            }
+            catch (e) {
+                // Continue to check existing/loading state even if not strictly "visible" yet
+            }
+            // 2. Check Smart Loading State
+            if ((_a = this.config.strategies.loading) === null || _a === void 0 ? void 0 : _a.isHeaderLoading) {
+                const isStable = !(await this.config.strategies.loading.isHeaderLoading(context));
+                if (!isStable) {
+                    this.log('Headers are loading/unstable... waiting');
+                    await new Promise(r => setTimeout(r, 100));
+                    continue;
                 }
             }
-            throw lastError || new Error(`Timed out waiting for headers after ${headerTimeout}ms`);
-        });
+            // 3. Attempt Scan
+            try {
+                const rawHeaders = await strategy(context);
+                const entries = await this.processHeaders(rawHeaders);
+                // Success
+                this._headerMap = new Map(entries);
+                this.log(`Mapped ${entries.length} columns: ${JSON.stringify(entries.map(e => e[0]))}`);
+                return this._headerMap;
+            }
+            catch (e) {
+                lastError = e;
+                this.log(`Header mapping failed. Attempt ${Math.floor((Date.now() - startTime) / 100)}: ${e.message}`);
+                await new Promise(r => setTimeout(r, 100));
+            }
+        }
+        throw lastError || new Error(`Timed out waiting for headers after ${headerTimeout}ms`);
     }
-    remapHeaders() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._headerMap = null;
-            yield this.getMap();
-        });
+    async remapHeaders() {
+        this._headerMap = null;
+        await this.getMap();
     }
     getMapSync() {
         return this._headerMap;
@@ -95,43 +82,41 @@ class TableMapper {
     clear() {
         this._headerMap = null;
     }
-    processHeaders(rawHeaders) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const seenHeaders = new Set();
-            const entries = [];
-            for (let i = 0; i < rawHeaders.length; i++) {
-                let text = rawHeaders[i].trim() || `__col_${i}`;
-                if (this.config.headerTransformer) {
-                    text = yield this.config.headerTransformer({
-                        text,
-                        index: i,
-                        locator: this.resolve(this.config.headerSelector, this.rootLocator).nth(i),
-                        seenHeaders
-                    });
-                }
-                this.log(`Header mapping index ${i}: "${text}"`);
-                entries.push([text, i]);
-                seenHeaders.add(text);
-            }
-            // Validation: Check for empty table
-            if (entries.length === 0) {
-                throw new Error(`Initialization Error: No columns found using selector "${this.config.headerSelector}". Check your selector or ensure the table is visible.`);
-            }
-            // Validation: Check for duplicates
-            const seen = new Set();
-            const duplicates = new Set();
-            for (const [name] of entries) {
-                if (seen.has(name)) {
-                    duplicates.add(name);
-                }
-                seen.add(name);
+    async processHeaders(rawHeaders) {
+        const seenHeaders = new Set();
+        const entries = [];
+        for (let i = 0; i < rawHeaders.length; i++) {
+            let text = rawHeaders[i].trim() || `__col_${i}`;
+            if (this.config.headerTransformer) {
+                text = await this.config.headerTransformer({
+                    text,
+                    index: i,
+                    locator: this.resolve(this.config.headerSelector, this.rootLocator).nth(i),
+                    seenHeaders
+                });
             }
-            if (duplicates.size > 0) {
-                const dupList = Array.from(duplicates).map(d => `"${d}"`).join(', ');
-                throw new Error(`Initialization Error: Duplicate column names found: ${dupList}. Use 'headerTransformer' to rename duplicate columns.`);
+            this.log(`Header mapping index ${i}: "${text}"`);
+            entries.push([text, i]);
+            seenHeaders.add(text);
+        }
+        // Validation: Check for empty table
+        if (entries.length === 0) {
+            throw new Error(`Initialization Error: No columns found using selector "${this.config.headerSelector}". Check your selector or ensure the table is visible.`);
+        }
+        // Validation: Check for duplicates
+        const seen = new Set();
+        const duplicates = new Set();
+        for (const [name] of entries) {
+            if (seen.has(name)) {
+                duplicates.add(name);
             }
-            return entries;
-        });
+            seen.add(name);
+        }
+        if (duplicates.size > 0) {
+            const dupList = Array.from(duplicates).map(d => `"${d}"`).join(', ');
+            throw new Error(`Initialization Error: Duplicate column names found: ${dupList}. Use 'headerTransformer' to rename duplicate columns.`);
+        }
+        return entries;
     }
 }
 exports.TableMapper = TableMapper;

package/dist/minimalConfigContext.d.ts

@@ -3,4 +3,4 @@
  * This file is generated by scripts/embed-config-types.mjs
  * It contains minimal type definitions for config generation prompts.
  */
-export declare const MINIMAL_CONFIG_CONTEXT = "\n/**\n * Flexible selector type - can be a CSS string or function returning a Locator.\n * @example\n * // String selector\n * rowSelector: 'tbody tr'\n * \n * // Function selector\n * rowSelector: (root) => root.locator('[role=\"row\"]')\n */\nexport type Selector = string | ((root: Locator | Page) => Locator);\n\n/**\n * Debug configuration for development and troubleshooting\n */\nexport type DebugConfig = {\n  slow?: number | {\n    pagination?: number;\n    getCell?: number;\n    findRow?: number;\n    default?: number;\n  };\n  logLevel?: 'verbose' | 'info' | 'error' | 'none';\n};\n\n/**\n * Configuration options for useTable - focus on selectors and basic setup\n */\nexport interface TableConfig<T = any> {\n  /** CSS selector or function for table headers */\n  headerSelector?: string | ((root: Locator) => Locator);\n  \n  /** CSS selector or function for table rows */\n  rowSelector?: string | ((root: Locator) => Locator);\n  \n  /** CSS selector or function for cells within a row */\n  cellSelector?: string | ((row: Locator) => Locator);\n  \n  /** Transform header text (e.g., normalize, deduplicate) */\n  headerTransformer?: (args: { \n    text: string; \n    index: number; \n    locator: Locator;\n    seenHeaders: Set<string>;\n  }) => string | Promise<string>;\n  \n  /** Automatically scroll to table on init (default: true) */\n  autoScroll?: boolean;\n  \n  /** Debug options for development and troubleshooting */\n  debug?: DebugConfig;\n  \n  /** Advanced: Custom strategies for pagination, sorting, navigation, etc. */\n  strategies?: TableStrategies;\n}\n\n/**\n * Example usage:\n */\n// const table = useTable(page.locator('table'), {\n//   headerSelector: 'thead th',\n//   rowSelector: 'tbody tr',\n//   cellSelector: 'td',\n//   headerTransformer: ({ text }) => text.trim()\n// });\n\n";
+export declare const MINIMAL_CONFIG_CONTEXT = "\n/**\n * Flexible selector type - can be a CSS string or function returning a Locator.\n * @example\n * // String selector\n * rowSelector: 'tbody tr'\n * \n * // Function selector\n * headerSelector: (root) => root.locator('[role=\"columnheader\"]')\n */\nexport type Selector = string | ((root: Locator | Page) => Locator);\n\n/**\n * Debug configuration for development and troubleshooting\n */\nexport type DebugConfig = {\n  slow?: number | {\n    pagination?: number;\n    getCell?: number;\n    findRow?: number;\n    default?: number;\n  };\n  logLevel?: 'verbose' | 'info' | 'error' | 'none';\n};\n\n/**\n * Configuration options for useTable - focus on selectors and basic setup\n */\nexport interface TableConfig<T = any> {\n  /** CSS selector or function for table headers */\n  headerSelector?: string | ((root: Locator) => Locator);\n  \n  /** CSS selector or function for table rows */\n  rowSelector?: string | ((root: Locator) => Locator);\n  \n  /** CSS selector or function for cells within a row */\n  cellSelector?: string | ((row: Locator) => Locator);\n  \n  /** Transform header text (e.g., normalize, deduplicate) */\n  headerTransformer?: (args: { \n    text: string; \n    index: number; \n    locator: Locator;\n    seenHeaders: Set<string>;\n  }) => string | Promise<string>;\n  \n  /** Automatically scroll to table on init (default: true) */\n  autoScroll?: boolean;\n  \n  /** Debug options for development and troubleshooting */\n  debug?: DebugConfig;\n  \n  /** Advanced: Custom strategies for pagination, sorting, navigation, etc. */\n  strategies?: TableStrategies;\n}\n\n/**\n * Example usage:\n */\n// const table = useTable(page.locator('table'), {\n//   headerSelector: 'thead th',\n//   rowSelector: 'tbody tr',\n//   cellSelector: 'td',\n//   headerTransformer: ({ text }) => text.trim()\n// });\n\n";

package/dist/minimalConfigContext.js

@@ -14,7 +14,7 @@ exports.MINIMAL_CONFIG_CONTEXT = `
  * rowSelector: 'tbody tr'
  * 
  * // Function selector
- * rowSelector: (root) => root.locator('[role="row"]')
+ * headerSelector: (root) => root.locator('[role="columnheader"]')
  */
 export type Selector = string | ((root: Locator | Page) => Locator);
 

package/dist/packageVersion.d.ts

@@ -3,4 +3,4 @@
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.9.0";
+export declare const PLAYWRIGHT_SMART_TABLE_VERSION: "6.10.1";

package/dist/packageVersion.js

@@ -6,4 +6,4 @@ exports.PLAYWRIGHT_SMART_TABLE_VERSION = void 0;
  * Generated by scripts/embed-version.mjs from package.json
  */
 /** Semver of this package. Use in logs or diagnostics to confirm the installed build. */
-exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.9.0";
+exports.PLAYWRIGHT_SMART_TABLE_VERSION = "6.10.1";

package/dist/presets/glide/columns.js

@@ -1,13 +1,4 @@
 "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.glideSnapFirstColumnIntoView = exports.glideSeekColumnIndex = exports.glideGoRight = exports.glideGoLeft = exports.glideGoDown = exports.glideGoUp = void 0;
 /**
@@ -15,48 +6,48 @@ exports.glideSnapFirstColumnIntoView = exports.glideSeekColumnIndex = exports.gl
  * These define HOW to move, not WHEN to move.
  * The orchestration logic lives in _navigateToCell.
  */
-const glideGoUp = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    yield context.page.keyboard.press('ArrowUp');
-});
+const glideGoUp = async (context) => {
+    await context.page.keyboard.press('ArrowUp');
+};
 exports.glideGoUp = glideGoUp;
-const glideGoDown = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    yield context.page.keyboard.press('ArrowDown');
-});
+const glideGoDown = async (context) => {
+    await context.page.keyboard.press('ArrowDown');
+};
 exports.glideGoDown = glideGoDown;
 // Horizontal: use page `.dvn-scroller` (canvas root is not its ancestor). Virtualized rows expose
 // a small window of `td[aria-colindex]` that shifts with scrollLeft.
-const nudgePageScroller = (page, delta) => __awaiter(void 0, void 0, void 0, function* () {
+const nudgePageScroller = async (page, delta) => {
     const scroller = page.locator('.dvn-scroller').first();
-    yield scroller.evaluate((el, d) => {
+    await scroller.evaluate((el, d) => {
         el.scrollLeft += d;
     }, delta);
-});
-const glideGoLeft = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    yield nudgePageScroller(context.page, -400);
-});
+};
+const glideGoLeft = async (context) => {
+    await nudgePageScroller(context.page, -400);
+};
 exports.glideGoLeft = glideGoLeft;
-const glideGoRight = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    yield nudgePageScroller(context.page, 400);
-});
+const glideGoRight = async (context) => {
+    await nudgePageScroller(context.page, 400);
+};
 exports.glideGoRight = glideGoRight;
 /** Coarse `scrollLeft` toward `columnIndex`; `goLeft`/`goRight` correct the remainder. */
-const glideSeekColumnIndex = (context, columnIndex) => __awaiter(void 0, void 0, void 0, function* () {
+const glideSeekColumnIndex = async (context, columnIndex) => {
     const { page } = context;
     const scroller = page.locator('.dvn-scroller').first();
-    yield scroller.evaluate((el, colIdx) => {
+    await scroller.evaluate((el, colIdx) => {
         const max = Math.max(0, el.scrollWidth - el.clientWidth);
         const ratio = Math.min(1, Math.max(0, (colIdx + 0.5) / 64));
         el.scrollLeft = Math.floor(ratio * max);
     }, columnIndex);
-    yield page.waitForTimeout(100);
-});
+    await page.waitForTimeout(100);
+};
 exports.glideSeekColumnIndex = glideSeekColumnIndex;
 /** `scrollLeft = 0` so low `aria-colindex` cells exist again (see smartRow for optional `Home`). */
-const glideSnapFirstColumnIntoView = (context) => __awaiter(void 0, void 0, void 0, function* () {
+const glideSnapFirstColumnIntoView = async (context) => {
     const { page } = context;
-    yield page.locator('.dvn-scroller').first().evaluate((el) => {
+    await page.locator('.dvn-scroller').first().evaluate((el) => {
         el.scrollLeft = 0;
     });
-    yield page.waitForTimeout(150);
-});
+    await page.waitForTimeout(150);
+};
 exports.glideSnapFirstColumnIntoView = glideSnapFirstColumnIntoView;