@rickcedwhat/playwright-smart-table 6.7.3 → 6.7.5

package/README.md

@@ -99,6 +99,8 @@ for await (const { row, rowIndex } of table) {
 }
 ```
 
+When your pagination strategy supports bulk jumps (`goNextBulk`), pass `{ useBulkPagination: true }` to `map`/`forEach`/`filter` to advance by multiple pages at once.
+
 > **`map` + UI interactions:** `map` defaults to `parallel: true`. If your callback opens popovers,
 > fills inputs, or otherwise mutates UI state, pass `{ parallel: false }` to avoid overlapping interactions.
 

package/dist/engine/rowFinder.d.ts

@@ -19,7 +19,7 @@ export declare class RowFinder<T = any> {
         exact?: boolean;
         maxPages?: number;
     }): Promise<SmartRow<T>>;
-    findRows(filters?: Partial<T> | Record<string, FilterValue>, options?: {
+    findRows(filters?: Record<string, FilterValue>, options?: {
         exact?: boolean;
         maxPages?: number;
     }): Promise<SmartRowArray<T>>;

package/dist/engine/rowFinder.js

@@ -14,6 +14,7 @@ const debugUtils_1 = require("../utils/debugUtils");
 const smartRowArray_1 = require("../utils/smartRowArray");
 const validation_1 = require("../strategies/validation");
 const elementTracker_1 = require("../utils/elementTracker");
+const sentinel_1 = require("../utils/sentinel");
 class RowFinder {
     constructor(rootLocator, config, resolve, filterEngine, tableMapper, makeSmartRow, tableState = { currentPageIndex: 0 }) {
         this.rootLocator = rootLocator;
@@ -42,14 +43,14 @@ class RowFinder {
             const sentinel = this.resolve(this.config.rowSelector, this.rootLocator)
                 .filter({ hasText: "___SENTINEL_ROW_NOT_FOUND___" + Date.now() });
             const smartRow = this.makeSmartRow(sentinel, yield this.tableMapper.getMap(), 0);
-            smartRow._isSentinel = true;
+            smartRow[sentinel_1.SENTINEL_ROW] = true;
             return smartRow;
         });
     }
-    findRows(filters, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const filtersRecord = filters || {};
+    findRows() {
+        return __awaiter(this, arguments, void 0, function* (filters = {}, options) {
+            var _a, _b, _c, _d;
+            const filtersRecord = filters;
             const map = yield this.tableMapper.getMap();
             const allRows = [];
             const effectiveMaxPages = (_b = (_a = options === null || options === void 0 ? void 0 : options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages) !== null && _b !== void 0 ? _b : Infinity;
@@ -85,19 +86,14 @@ class RowFinder {
                         page: this.rootLocator.page()
                     };
                     let paginationResult;
-                    if (typeof this.config.strategies.pagination === 'function') {
-                        paginationResult = yield this.config.strategies.pagination(context);
+                    if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
+                        paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
+                    }
+                    else if ((_d = this.config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) {
+                        paginationResult = yield this.config.strategies.pagination.goNext(context);
                     }
                     else {
-                        if (this.config.strategies.pagination.goNextBulk) {
-                            paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
-                        }
-                        else if (this.config.strategies.pagination.goNext) {
-                            paginationResult = yield this.config.strategies.pagination.goNext(context);
-                        }
-                        else {
-                            break;
-                        }
+                        break;
                     }
                     const didPaginate = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
                     if (!didPaginate)
@@ -116,7 +112,7 @@ class RowFinder {
     }
     findRowLocator(filters_1) {
         return __awaiter(this, arguments, void 0, function* (filters, options = {}) {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const map = yield this.tableMapper.getMap();
             const effectiveMaxPages = (_a = options.maxPages) !== null && _a !== void 0 ? _a : this.config.maxPages;
             let pagesScanned = 1;
@@ -166,20 +162,15 @@ class RowFinder {
                         page: this.rootLocator.page()
                     };
                     let paginationResult;
-                    if (typeof this.config.strategies.pagination === 'function') {
-                        paginationResult = yield this.config.strategies.pagination(context);
+                    if ((_c = this.config.strategies.pagination) === null || _c === void 0 ? void 0 : _c.goNextBulk) {
+                        paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
+                    }
+                    else if ((_d = this.config.strategies.pagination) === null || _d === void 0 ? void 0 : _d.goNext) {
+                        paginationResult = yield this.config.strategies.pagination.goNext(context);
                     }
                     else {
-                        if (this.config.strategies.pagination.goNextBulk) {
-                            paginationResult = yield this.config.strategies.pagination.goNextBulk(context);
-                        }
-                        else if (this.config.strategies.pagination.goNext) {
-                            paginationResult = yield this.config.strategies.pagination.goNext(context);
-                        }
-                        else {
-                            this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
-                            return null;
-                        }
+                        this.log(`Page ${this.tableState.currentPageIndex}: Pagination failed (no goNext or goNextBulk primitive).`);
+                        return null;
                     }
                     const didLoadMore = (0, validation_1.validatePaginationResult)(paginationResult, 'Pagination Strategy');
                     if (didLoadMore) {

package/dist/engine/tableIteration.d.ts

@@ -0,0 +1,25 @@
+import type { Locator, Page } from '@playwright/test';
+import type { SmartRow, RowIterationContext, RowIterationOptions } from '../types';
+import type { FinalTableConfig } from '../types';
+import type { SmartRowArray } from '../utils/smartRowArray';
+export interface TableIterationEnv<T = any> {
+    getRowLocators: () => Locator;
+    getMap: () => Map<string, number>;
+    advancePage: (useBulk: boolean) => Promise<boolean>;
+    makeSmartRow: (rowLocator: Locator, map: Map<string, number>, rowIndex: number, tablePageIndex?: number) => SmartRow<T>;
+    createSmartRowArray: (rows: SmartRow<T>[]) => SmartRowArray<T>;
+    config: FinalTableConfig<T>;
+    getPage: () => Page;
+}
+/**
+ * Shared row-iteration loop used by forEach, map, and filter.
+ */
+export declare function runForEach<T>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => void | Promise<void>, options?: RowIterationOptions): Promise<void>;
+/**
+ * Shared row-iteration loop for map.
+ */
+export declare function runMap<T, R>(env: TableIterationEnv<T>, callback: (ctx: RowIterationContext<T>) => R | Promise<R>, options?: RowIterationOptions): Promise<R[]>;
+/**
+ * Shared row-iteration loop for filter.
+ */
+export declare function runFilter<T>(env: TableIterationEnv<T>, predicate: (ctx: RowIterationContext<T>) => boolean | Promise<boolean>, options?: RowIterationOptions): Promise<SmartRowArray<T>>;

package/dist/engine/tableIteration.js

@@ -0,0 +1,210 @@
+"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;
+exports.runFilter = runFilter;
+const elementTracker_1 = require("../utils/elementTracker");
+/**
+ * Shared row-iteration loop used by forEach, map, and filter.
+ */
+function runForEach(env_1, callback_1) {
+    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}) {
+        var _a, _b, _c, _d;
+        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 parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
+        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
+        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 = env.getRowLocators();
+                const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                const pageRows = yield rowLocators.all();
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i));
+                if (parallel) {
+                    yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                        if (stopped)
+                            return;
+                        if (dedupeKeys && dedupeStrategy) {
+                            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 && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                continue;
+                            dedupeKeys.add(key);
+                        }
+                        yield callback({ row, rowIndex: row.rowIndex, stop });
+                    }
+                }
+                rowIndex += smartRows.length;
+                if (stopped || pagesScanned >= effectiveMaxPages)
+                    break;
+                if (!(yield env.advancePage(useBulk)))
+                    break;
+                pagesScanned++;
+            }
+        }
+        finally {
+            yield tracker.cleanup(env.getPage());
+        }
+    });
+}
+/**
+ * Shared row-iteration loop for map.
+ */
+function runMap(env_1, callback_1) {
+    return __awaiter(this, arguments, void 0, function* (env, callback, options = {}) {
+        var _a, _b, _c, _d;
+        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 parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : true;
+        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
+        const tracker = new elementTracker_1.ElementTracker('map');
+        const results = [];
+        const SKIP = Symbol('skip');
+        try {
+            let rowIndex = 0;
+            let stopped = false;
+            let pagesScanned = 1;
+            const stop = () => { stopped = true; };
+            while (!stopped) {
+                const rowLocators = env.getRowLocators();
+                const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                const pageRows = yield rowLocators.all();
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i));
+                if (parallel) {
+                    const pageResults = yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                        if (dedupeKeys && dedupeStrategy) {
+                            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);
+                    }
+                }
+                else {
+                    for (const row of smartRows) {
+                        if (stopped)
+                            break;
+                        if (dedupeKeys && dedupeStrategy) {
+                            const key = yield dedupeStrategy(row);
+                            if (dedupeKeys.has(key))
+                                continue;
+                            dedupeKeys.add(key);
+                        }
+                        results.push(yield callback({ row, rowIndex: row.rowIndex, stop }));
+                    }
+                }
+                rowIndex += smartRows.length;
+                if (stopped || pagesScanned >= effectiveMaxPages)
+                    break;
+                if (!(yield env.advancePage(useBulk)))
+                    break;
+                pagesScanned++;
+            }
+        }
+        finally {
+            yield tracker.cleanup(env.getPage());
+        }
+        return results;
+    });
+}
+/**
+ * Shared row-iteration loop for filter.
+ */
+function runFilter(env_1, predicate_1) {
+    return __awaiter(this, arguments, void 0, function* (env, predicate, options = {}) {
+        var _a, _b, _c, _d;
+        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 parallel = (_c = options.parallel) !== null && _c !== void 0 ? _c : false;
+        const useBulk = (_d = options.useBulkPagination) !== null && _d !== void 0 ? _d : false;
+        const tracker = new elementTracker_1.ElementTracker('filter');
+        const matched = [];
+        try {
+            let rowIndex = 0;
+            let stopped = false;
+            let pagesScanned = 1;
+            const stop = () => { stopped = true; };
+            while (!stopped) {
+                const rowLocators = env.getRowLocators();
+                const newIndices = yield tracker.getUnseenIndices(rowLocators);
+                const pageRows = yield rowLocators.all();
+                const smartRows = newIndices.map((idx, i) => env.makeSmartRow(pageRows[idx], map, rowIndex + i, pagesScanned - 1));
+                if (parallel) {
+                    const flags = yield Promise.all(smartRows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                        if (dedupeKeys && dedupeStrategy) {
+                            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 && dedupeStrategy) {
+                            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 env.advancePage(useBulk)))
+                    break;
+                pagesScanned++;
+            }
+        }
+        finally {
+            yield tracker.cleanup(env.getPage());
+        }
+        return env.createSmartRowArray(matched);
+    });
+}

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  /** Custom data mappers for extracting complex types (boolean, number) */\n  dataMapper?: Partial<Record<keyof T, (cell: Locator) => Promise<T[keyof T]> | T[keyof T]>>;\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 * 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";

package/dist/minimalConfigContext.js

@@ -60,9 +60,6 @@ export interface TableConfig<T = any> {
   
   /** Advanced: Custom strategies for pagination, sorting, navigation, etc. */
   strategies?: TableStrategies;
-  
-  /** Custom data mappers for extracting complex types (boolean, number) */
-  dataMapper?: Partial<Record<keyof T, (cell: Locator) => Promise<T[keyof T]> | T[keyof T]>>;
 }
 
 /**

package/dist/plugins/glide/columns.d.ts

@@ -0,0 +1,11 @@
+import { StrategyContext } from '../../types';
+/**
+ * Primitive navigation functions for Glide Data Grid.
+ * These define HOW to move, not WHEN to move.
+ * The orchestration logic lives in _navigateToCell.
+ */
+export declare const glideGoUp: (context: StrategyContext) => Promise<void>;
+export declare const glideGoDown: (context: StrategyContext) => Promise<void>;
+export declare const glideGoLeft: (context: StrategyContext) => Promise<void>;
+export declare const glideGoRight: (context: StrategyContext) => Promise<void>;
+export declare const glideGoHome: (context: StrategyContext) => Promise<void>;

package/dist/plugins/glide/columns.js

@@ -0,0 +1,51 @@
+"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.glideGoHome = exports.glideGoRight = exports.glideGoLeft = exports.glideGoDown = exports.glideGoUp = void 0;
+/**
+ * Primitive navigation functions for Glide Data Grid.
+ * 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');
+});
+exports.glideGoUp = glideGoUp;
+const glideGoDown = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    yield context.page.keyboard.press('ArrowDown');
+});
+exports.glideGoDown = glideGoDown;
+const glideGoLeft = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    yield context.page.keyboard.press('ArrowLeft');
+});
+exports.glideGoLeft = glideGoLeft;
+const glideGoRight = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    yield context.page.keyboard.press('ArrowRight');
+});
+exports.glideGoRight = glideGoRight;
+const glideGoHome = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const { root, page } = context;
+    // Glide renders to canvas - the accessibility table (root) is inside the canvas
+    yield root.evaluate((el) => {
+        var _a;
+        const canvas = el.closest('canvas') || ((_a = el.parentElement) === null || _a === void 0 ? void 0 : _a.querySelector('canvas'));
+        if (canvas instanceof HTMLCanvasElement) {
+            canvas.tabIndex = 0;
+            canvas.focus();
+        }
+    });
+    yield page.waitForTimeout(100);
+    yield page.keyboard.press('Control+Home');
+    yield page.keyboard.press('Meta+ArrowUp');
+    yield page.keyboard.press('Home');
+    yield page.waitForTimeout(150);
+});
+exports.glideGoHome = glideGoHome;

package/dist/plugins/glide/headers.d.ts

@@ -0,0 +1,9 @@
+import { StrategyContext } from '../../types';
+/**
+ * Scans for headers by finding a scrollable container and setting scrollLeft.
+ */
+export declare const scrollRightHeader: (context: StrategyContext, options?: {
+    limit?: number;
+    selector?: string;
+    scrollAmount?: number;
+}) => Promise<string[]>;

package/dist/plugins/glide/headers.js

@@ -0,0 +1,65 @@
+"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.scrollRightHeader = void 0;
+/**
+ * Scans for headers by finding a scrollable container and setting scrollLeft.
+ */
+const scrollRightHeader = (context, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { resolve, config, root, page } = context;
+    const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : 20;
+    const scrollAmount = (_b = options === null || options === void 0 ? void 0 : options.scrollAmount) !== null && _b !== void 0 ? _b : 300;
+    const collectedHeaders = new Set();
+    const getVisible = () => __awaiter(void 0, void 0, void 0, function* () {
+        const headerLoc = resolve(config.headerSelector, root);
+        const texts = yield headerLoc.allInnerTexts();
+        return texts.map(t => t.trim());
+    });
+    let currentHeaders = yield getVisible();
+    currentHeaders.forEach(h => collectedHeaders.add(h));
+    const scrollerHandle = yield root.evaluateHandle((el, selector) => {
+        if (selector && el.matches(selector))
+            return el;
+        const effectiveSelector = selector || '.dvn-scroller';
+        const ancestor = el.closest(effectiveSelector);
+        if (ancestor)
+            return ancestor;
+        return document.querySelector(effectiveSelector);
+    }, options === null || options === void 0 ? void 0 : options.selector);
+    const isScrollerFound = yield scrollerHandle.evaluate(el => !!el);
+    if (isScrollerFound) {
+        yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
+        yield page.waitForTimeout(200);
+        for (let i = 0; i < limit; i++) {
+            const sizeBefore = collectedHeaders.size;
+            yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
+            yield page.waitForTimeout(300);
+            const newHeaders = yield getVisible();
+            newHeaders.forEach(h => collectedHeaders.add(h));
+            if (collectedHeaders.size === sizeBefore) {
+                yield scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
+                yield page.waitForTimeout(300);
+                const retryHeaders = yield getVisible();
+                retryHeaders.forEach(h => collectedHeaders.add(h));
+                if (collectedHeaders.size === sizeBefore)
+                    break;
+            }
+        }
+    }
+    else {
+        console.warn("HeaderStrategies.scrollRight: Could not find scroller. Returning visible headers.");
+    }
+    yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
+    yield page.waitForTimeout(200);
+    return Array.from(collectedHeaders);
+});
+exports.scrollRightHeader = scrollRightHeader;

package/dist/plugins/glide/index.d.ts

@@ -0,0 +1,31 @@
+import { FillStrategy, TableConfig } from '../../types';
+/** Strategies only for Glide Data Grid. Includes fillSimple; use when you want to supply your own selectors or override fill. */
+export declare const GlideStrategies: {
+    fillSimple: FillStrategy;
+    fill: FillStrategy;
+    pagination: import("../../types").PaginationPrimitives;
+    header: (context: import("../../types").StrategyContext, options?: {
+        limit?: number;
+        selector?: string;
+        scrollAmount?: number;
+    }) => Promise<string[]>;
+    navigation: {
+        goUp: (context: import("../../types").StrategyContext) => Promise<void>;
+        goDown: (context: import("../../types").StrategyContext) => Promise<void>;
+        goLeft: (context: import("../../types").StrategyContext) => Promise<void>;
+        goRight: (context: import("../../types").StrategyContext) => Promise<void>;
+        goHome: (context: import("../../types").StrategyContext) => Promise<void>;
+    };
+    loading: {
+        isHeaderLoading: () => Promise<boolean>;
+    };
+    getCellLocator: ({ row, columnIndex }: any) => any;
+    getActiveCell: ({ page }: any) => Promise<{
+        rowIndex: number;
+        columnIndex: number;
+        locator: any;
+    } | null>;
+};
+export declare const Glide: Partial<TableConfig> & {
+    Strategies: typeof GlideStrategies;
+};

package/dist/plugins/glide/index.js

@@ -0,0 +1,104 @@
+"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.Glide = exports.GlideStrategies = void 0;
+const columns_1 = require("./columns");
+const headers_1 = require("./headers");
+const pagination_1 = require("../../strategies/pagination");
+const stabilization_1 = require("../../strategies/stabilization");
+const glideFillStrategy = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, page }) {
+    yield page.keyboard.press('Enter');
+    const textarea = page.locator('textarea.gdg-input');
+    yield textarea.waitFor({ state: 'visible', timeout: 2000 });
+    yield page.keyboard.type(String(value));
+    yield textarea.evaluate((el, expectedValue) => {
+        return new Promise((resolve) => {
+            const checkValue = () => {
+                if (el.value === expectedValue) {
+                    resolve();
+                }
+                else {
+                    setTimeout(checkValue, 10);
+                }
+            };
+            checkValue();
+        });
+    }, String(value));
+    yield page.waitForTimeout(50);
+    yield page.keyboard.press('Enter');
+    yield textarea.waitFor({ state: 'detached', timeout: 2000 });
+    yield page.waitForTimeout(300);
+});
+const glideFillSimple = (_a) => __awaiter(void 0, [_a], void 0, function* ({ value, page }) {
+    yield page.keyboard.press('Enter');
+    yield page.keyboard.type(String(value));
+    yield page.keyboard.press('Enter');
+});
+const glidePaginationStrategy = pagination_1.PaginationStrategies.infiniteScroll({
+    scrollTarget: 'xpath=//ancestor::body//div[contains(@class, "dvn-scroller")]',
+    scrollAmount: 500,
+    action: 'js-scroll',
+    stabilization: stabilization_1.StabilizationStrategies.contentChanged({ timeout: 5000 }),
+    timeout: 5000
+});
+const glideGetCellLocator = ({ row, columnIndex }) => {
+    return row.locator('td').nth(columnIndex);
+};
+const glideGetActiveCell = (_a) => __awaiter(void 0, [_a], void 0, function* ({ page }) {
+    const focused = page.locator('*:focus').first();
+    if ((yield focused.count()) === 0)
+        return null;
+    const id = (yield focused.getAttribute('id')) || '';
+    const parts = id.split('-');
+    let rowIndex = -1;
+    let columnIndex = -1;
+    if (parts.length >= 4 && parts[0] === 'glide' && parts[1] === 'cell') {
+        columnIndex = parseInt(parts[2]) - 1;
+        rowIndex = parseInt(parts[3]);
+    }
+    return {
+        rowIndex,
+        columnIndex,
+        locator: focused
+    };
+});
+/** Default strategies for the Glide preset (fill only; no fillSimple). */
+const GlideDefaultStrategies = {
+    fill: glideFillStrategy,
+    pagination: glidePaginationStrategy,
+    header: headers_1.scrollRightHeader,
+    navigation: {
+        goUp: columns_1.glideGoUp,
+        goDown: columns_1.glideGoDown,
+        goLeft: columns_1.glideGoLeft,
+        goRight: columns_1.glideGoRight,
+        goHome: columns_1.glideGoHome
+    },
+    loading: {
+        isHeaderLoading: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
+    },
+    getCellLocator: glideGetCellLocator,
+    getActiveCell: glideGetActiveCell
+};
+/** Strategies only for Glide Data Grid. Includes fillSimple; use when you want to supply your own selectors or override fill. */
+exports.GlideStrategies = Object.assign(Object.assign({}, GlideDefaultStrategies), { fillSimple: glideFillSimple });
+/**
+ * Full preset for Glide Data Grid (selectors + default strategies only).
+ * Spread: useTable(loc, { ...Plugins.Glide, maxPages: 5 }).
+ * Strategies only (including fillSimple): useTable(loc, { rowSelector: '...', strategies: Plugins.Glide.Strategies }).
+ */
+const GlidePreset = {
+    headerSelector: 'table[role="grid"] thead tr th',
+    rowSelector: 'table[role="grid"] tbody tr',
+    cellSelector: 'td',
+    strategies: GlideDefaultStrategies
+};
+exports.Glide = Object.defineProperty(GlidePreset, 'Strategies', { get: () => exports.GlideStrategies, enumerable: false });