@rickcedwhat/playwright-smart-table 6.8.2 → 6.10.0

package/dist/strategies/fill.js

@@ -1,31 +1,22 @@
 "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.FillStrategies = void 0;
 exports.FillStrategies = {
     /**
      * Default strategy: Detects input type and fills accordingly (Text, Select, Checkbox, ContentEditable).
      */
-    default: (_a) => __awaiter(void 0, [_a], void 0, function* ({ row, columnName, value, fillOptions, config, table }) {
-        var _b, _c;
+    default: async ({ row, columnName, value, fillOptions, config, table }) => {
+        var _a, _b;
         const cell = row.getCell(columnName);
         // 1. Check for Unified Column Override
-        const columnOverride = (_b = config === null || config === void 0 ? void 0 : config.columnOverrides) === null || _b === void 0 ? void 0 : _b[columnName];
+        const columnOverride = (_a = config === null || config === void 0 ? void 0 : config.columnOverrides) === null || _a === void 0 ? void 0 : _a[columnName];
         if (columnOverride === null || columnOverride === void 0 ? void 0 : columnOverride.write) {
             let currentValue;
             // Auto-sync: If read exists, get current state first
             if (columnOverride.read) {
-                currentValue = yield columnOverride.read(cell);
+                currentValue = await columnOverride.read(cell);
             }
-            yield columnOverride.write({
+            await columnOverride.write({
                 cell,
                 targetValue: value,
                 currentValue,
@@ -35,23 +26,23 @@ exports.FillStrategies = {
         }
         // Use custom input mapper for this column if provided, otherwise auto-detect
         let inputLocator;
-        if ((_c = fillOptions === null || fillOptions === void 0 ? void 0 : fillOptions.inputMappers) === null || _c === void 0 ? void 0 : _c[columnName]) {
+        if ((_b = fillOptions === null || fillOptions === void 0 ? void 0 : fillOptions.inputMappers) === null || _b === void 0 ? void 0 : _b[columnName]) {
             inputLocator = fillOptions.inputMappers[columnName](cell);
         }
         else {
             // Auto-detect input type
             // Check for text input
             const textInput = cell.locator('input[type="text"], input:not([type]), textarea').first();
-            const textInputCount = yield textInput.count().catch(() => 0);
+            const textInputCount = await textInput.count().catch(() => 0);
             // Check for select
             const select = cell.locator('select').first();
-            const selectCount = yield select.count().catch(() => 0);
+            const selectCount = await select.count().catch(() => 0);
             // Check for checkbox/radio
             const checkbox = cell.locator('input[type="checkbox"], input[type="radio"], [role="checkbox"]').first();
-            const checkboxCount = yield checkbox.count().catch(() => 0);
+            const checkboxCount = await checkbox.count().catch(() => 0);
             // Check for contenteditable or div-based inputs
             const contentEditable = cell.locator('[contenteditable="true"]').first();
-            const contentEditableCount = yield contentEditable.count().catch(() => 0);
+            const contentEditableCount = await contentEditable.count().catch(() => 0);
             // Determine which input to use (prioritize by commonality)
             if (textInputCount > 0 && selectCount === 0 && checkboxCount === 0) {
                 inputLocator = textInput;
@@ -75,30 +66,30 @@ exports.FillStrategies = {
             }
         }
         // Fill based on value type and input type
-        const inputTag = yield inputLocator.evaluate((el) => el.tagName.toLowerCase()).catch(() => 'unknown');
-        const inputType = yield inputLocator.getAttribute('type').catch(() => null);
-        const isContentEditable = yield inputLocator.getAttribute('contenteditable').catch(() => null);
+        const inputTag = await inputLocator.evaluate((el) => el.tagName.toLowerCase()).catch(() => 'unknown');
+        const inputType = await inputLocator.getAttribute('type').catch(() => null);
+        const isContentEditable = await inputLocator.getAttribute('contenteditable').catch(() => null);
         // console.log(`[SmartTable] Filling "${columnName}" with value "${value}" (input: ${inputTag}, type: ${inputType})`);
         if (inputType === 'checkbox' || inputType === 'radio') {
             // Boolean value for checkbox/radio
             const shouldBeChecked = Boolean(value);
-            const isChecked = yield inputLocator.isChecked().catch(() => false);
+            const isChecked = await inputLocator.isChecked().catch(() => false);
             if (isChecked !== shouldBeChecked) {
-                yield inputLocator.click();
+                await inputLocator.click();
             }
         }
         else if (inputTag === 'select') {
             // Select dropdown
-            yield inputLocator.selectOption(String(value));
+            await inputLocator.selectOption(String(value));
         }
         else if (isContentEditable === 'true') {
             // Contenteditable div
-            yield inputLocator.click();
-            yield inputLocator.fill(String(value));
+            await inputLocator.click();
+            await inputLocator.fill(String(value));
         }
         else {
             // Text input, textarea, or generic
-            yield inputLocator.fill(String(value));
+            await inputLocator.fill(String(value));
         }
-    })
+    }
 };

package/dist/strategies/headers.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.HeaderStrategies = void 0;
 exports.HeaderStrategies = {
@@ -15,37 +6,37 @@ exports.HeaderStrategies = {
      * Default strategy: Returns only the headers currently visible in the DOM.
      * This is fast but won't find virtualized columns off-screen.
      */
-    visible: (_a) => __awaiter(void 0, [_a], void 0, function* ({ config, resolve, root }) {
+    visible: async ({ config, resolve, root }) => {
         const headerLoc = resolve(config.headerSelector, root);
         try {
             // Wait for at least one header to be visible
-            yield headerLoc.first().waitFor({ state: 'visible', timeout: 3000 });
+            await headerLoc.first().waitFor({ state: 'visible', timeout: 3000 });
         }
         catch (e) {
             // Ignore hydration/timeout issues, return what we have
         }
-        const texts = yield headerLoc.allInnerTexts();
+        const texts = await headerLoc.allInnerTexts();
         return texts.map(t => t.trim());
-    }),
+    },
     /**
      * Physically scrolls the table horizontally to force virtualized columns to mount,
      * collecting their names along the way.
      */
     horizontalScroll: (options) => {
-        return (context) => __awaiter(void 0, void 0, void 0, function* () {
+        return async (context) => {
             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 getVisible = async () => {
                 const headerLoc = resolve(config.headerSelector, root);
-                const texts = yield headerLoc.allInnerTexts();
+                const texts = await headerLoc.allInnerTexts();
                 return texts.map(t => t.trim());
-            });
-            let currentHeaders = yield getVisible();
+            };
+            let currentHeaders = await getVisible();
             currentHeaders.forEach(h => collectedHeaders.add(h));
-            const scrollerHandle = yield root.evaluateHandle((el, selector) => {
+            const scrollerHandle = await root.evaluateHandle((el, selector) => {
                 if (selector && el.matches(selector))
                     return el;
                 // Try finding common scrollable containers or fallback to root
@@ -58,20 +49,20 @@ exports.HeaderStrategies = {
                     return child;
                 return el;
             }, options === null || options === void 0 ? void 0 : options.selector);
-            const isScrollerFound = yield scrollerHandle.evaluate(el => !!el);
+            const isScrollerFound = await scrollerHandle.evaluate(el => !!el);
             if (isScrollerFound) {
-                yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
-                yield page.waitForTimeout(200);
+                await scrollerHandle.evaluate(el => el.scrollLeft = 0);
+                await 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();
+                    await scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
+                    await page.waitForTimeout(300);
+                    const newHeaders = await 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();
+                        await scrollerHandle.evaluate((el, amount) => el.scrollLeft += amount, scrollAmount);
+                        await page.waitForTimeout(300);
+                        const retryHeaders = await getVisible();
                         retryHeaders.forEach(h => collectedHeaders.add(h));
                         if (collectedHeaders.size === sizeBefore)
                             break;
@@ -81,9 +72,9 @@ exports.HeaderStrategies = {
             else {
                 console.warn("HeaderStrategies.horizontalScroll: Could not find scroller. Returning visible headers.");
             }
-            yield scrollerHandle.evaluate(el => el.scrollLeft = 0);
-            yield page.waitForTimeout(200);
+            await scrollerHandle.evaluate(el => el.scrollLeft = 0);
+            await page.waitForTimeout(200);
             return Array.from(collectedHeaders);
-        });
+        };
     }
 };

package/dist/strategies/index.d.ts

@@ -8,6 +8,7 @@ export * from './dedupe';
 export * from './loading';
 export * from './stabilization';
 export * from './filter';
+export * from './viewport';
 export declare const Strategies: {
     Pagination: {
         click: (selectors: {
@@ -89,4 +90,7 @@ export declare const Strategies: {
             called?: boolean;
         }) => import("./filter").FilterStrategy;
     };
+    Viewport: {
+        dataAttribute: (options?: import("./viewport").DataAttributeViewportOptions) => import("../types").ViewportStrategy;
+    };
 };

package/dist/strategies/index.js

@@ -25,6 +25,7 @@ const dedupe_1 = require("./dedupe");
 const loading_1 = require("./loading");
 const stabilization_1 = require("./stabilization");
 const filter_1 = require("./filter");
+const viewport_1 = require("./viewport");
 __exportStar(require("./pagination"), exports);
 __exportStar(require("./sorting"), exports);
 __exportStar(require("./columns"), exports);
@@ -35,6 +36,7 @@ __exportStar(require("./dedupe"), exports);
 __exportStar(require("./loading"), exports);
 __exportStar(require("./stabilization"), exports);
 __exportStar(require("./filter"), exports);
+__exportStar(require("./viewport"), exports);
 exports.Strategies = {
     Pagination: pagination_1.PaginationStrategies,
     Sorting: sorting_1.SortingStrategies,
@@ -46,4 +48,5 @@ exports.Strategies = {
     Loading: loading_1.LoadingStrategies,
     Stabilization: stabilization_1.StabilizationStrategies,
     Filter: filter_1.FilterStrategies,
+    Viewport: viewport_1.ViewportStrategies,
 };

package/dist/strategies/loading.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.LoadingStrategies = void 0;
 /**
@@ -23,16 +14,16 @@ exports.LoadingStrategies = {
          * Checks if a global spinner or loading overlay is visible.
          * @param selector Selector for the loading indicator (e.g. '.loading-spinner')
          */
-        hasSpinner: (selector = '.loading-spinner') => (_a) => __awaiter(void 0, [_a], void 0, function* ({ root }) {
+        hasSpinner: (selector = '.loading-spinner') => async ({ root }) => {
             // Check if spinner exists and is visible within the table wrapper or page
             const spinner = root.locator(selector).first();
             try {
-                return yield spinner.isVisible();
+                return await spinner.isVisible();
             }
-            catch (_b) {
+            catch (_a) {
                 return false;
             }
-        }),
+        },
         /**
          * Custom function to determine table loading state.
          */
@@ -40,7 +31,7 @@ exports.LoadingStrategies = {
         /**
          * Assume table is never loading (default).
          */
-        never: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
+        never: async () => false
     },
     /**
      * Strategies for detecting if a specific row is loading (e.g. Skeleton).
@@ -50,34 +41,34 @@ exports.LoadingStrategies = {
          * Checks if the row contains a specific class indicating it's a skeleton/loading row.
          * @param className Class name acting as the loading indicator (default: 'skeleton')
          */
-        hasClass: (className = 'skeleton') => (row) => __awaiter(void 0, void 0, void 0, function* () {
-            const cls = yield row.getAttribute('class');
+        hasClass: (className = 'skeleton') => async (row) => {
+            const cls = await row.getAttribute('class');
             return cls ? cls.includes(className) : false;
-        }),
+        },
         /**
          * Checks if the row's text content matches a "Loading..." string or regex.
          */
-        hasText: (text = 'Loading...') => (row) => __awaiter(void 0, void 0, void 0, function* () {
-            const content = yield row.innerText();
+        hasText: (text = 'Loading...') => async (row) => {
+            const content = await row.innerText();
             if (typeof text === 'string')
                 return content.includes(text);
             return text.test(content);
-        }),
+        },
         /**
          * Checks if the row has any cell with empty/falsy content (if strict).
          * Useful if rows render with empty cells before populating.
          */
-        hasEmptyCells: () => (row) => __awaiter(void 0, void 0, void 0, function* () {
+        hasEmptyCells: () => async (row) => {
             // Logic: Get all cells, check if any are empty.
             // Note: This might be expensive if done for every row check.
             // Simplified: check if InnerText is empty or very short?
-            const text = yield row.innerText();
+            const text = await row.innerText();
             return !text.trim();
-        }),
+        },
         /**
          * Assume row is never loading (default).
          */
-        never: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
+        never: async () => false
     },
     /**
      * Strategies for detecting if headers are loading/stable.
@@ -87,16 +78,16 @@ exports.LoadingStrategies = {
          * Checks if the headers are stable (count and text) for a specified duration.
          * @param duration Duration in ms for headers to remain unchanged to be considered stable (default: 200).
          */
-        stable: (duration = 200) => (context) => __awaiter(void 0, void 0, void 0, function* () {
+        stable: (duration = 200) => async (context) => {
             const { config, resolve, root } = context;
-            const getHeaderTexts = () => __awaiter(void 0, void 0, void 0, function* () {
-                const headers = yield resolve(config.headerSelector, root).all();
+            const getHeaderTexts = async () => {
+                const headers = await resolve(config.headerSelector, root).all();
                 return Promise.all(headers.map(h => h.innerText()));
-            });
-            const initial = yield getHeaderTexts();
+            };
+            const initial = await getHeaderTexts();
             // Wait for duration
-            yield context.page.waitForTimeout(duration);
-            const current = yield getHeaderTexts();
+            await context.page.waitForTimeout(duration);
+            const current = await getHeaderTexts();
             if (initial.length !== current.length)
                 return true; // Count changed, still loading
             for (let i = 0; i < initial.length; i++) {
@@ -104,10 +95,10 @@ exports.LoadingStrategies = {
                     return true; // Content changed, still loading
             }
             return false; // Stable
-        }),
+        },
         /**
          * Assume headers are never loading (immediate snapshot).
          */
-        never: () => __awaiter(void 0, void 0, void 0, function* () { return false; })
+        never: async () => false
     }
 };

package/dist/strategies/pagination.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.PaginationStrategies = void 0;
 const stabilization_1 = require("./stabilization");
@@ -18,16 +9,16 @@ exports.PaginationStrategies = {
         const createClicker = (selector, returnVal = true) => {
             if (!selector)
                 return undefined;
-            return (context) => __awaiter(void 0, void 0, void 0, function* () {
+            return async (context) => {
                 const { root, resolve } = context;
                 const btn = resolve(selector, root).first();
-                if (!btn || !(yield btn.isVisible()) || !(yield btn.isEnabled())) {
+                if (!btn || !await btn.isVisible() || !await btn.isEnabled()) {
                     return false;
                 }
-                return yield defaultStabilize(context, () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield btn.click({ timeout: 2000 }).catch(() => { });
-                })).then(stabilized => stabilized ? returnVal : false);
-            });
+                return await defaultStabilize(context, async () => {
+                    await btn.click({ timeout: 2000 }).catch(() => { });
+                }).then(stabilized => stabilized ? returnVal : false);
+            };
         };
         const nextBulk = (_b = options.nextBulkPages) !== null && _b !== void 0 ? _b : 10;
         const prevBulk = (_c = options.previousBulkPages) !== null && _c !== void 0 ? _c : 10;
@@ -58,45 +49,45 @@ exports.PaginationStrategies = {
         const stabilization = (_a = options.stabilization) !== null && _a !== void 0 ? _a : stabilization_1.StabilizationStrategies.rowCountIncreased({ timeout: options.timeout });
         const amount = (_b = options.scrollAmount) !== null && _b !== void 0 ? _b : 500;
         const createScroller = (directionMultiplier) => {
-            return (context) => __awaiter(void 0, void 0, void 0, function* () {
+            return async (context) => {
                 const { root, resolve, page } = context;
                 const scrollTarget = options.scrollTarget
                     ? resolve(options.scrollTarget, root)
                     : root;
-                const doScroll = () => __awaiter(void 0, void 0, void 0, function* () {
-                    const box = yield scrollTarget.boundingBox();
+                const doScroll = async () => {
+                    const box = await scrollTarget.boundingBox();
                     const scrollValue = amount * directionMultiplier;
                     // Action: Scroll
                     if (options.action === 'js-scroll' || !box) {
-                        yield scrollTarget.evaluate((el, y) => {
+                        await scrollTarget.evaluate((el, y) => {
                             el.scrollTop += y;
                         }, scrollValue);
                     }
                     else {
                         // Mouse Wheel
-                        yield page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
-                        yield page.mouse.wheel(0, scrollValue);
+                        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+                        await page.mouse.wheel(0, scrollValue);
                     }
-                });
+                };
                 // Stabilization: Wait
-                return yield stabilization(context, doScroll);
-            });
+                return await stabilization(context, doScroll);
+            };
         };
         const createGoToFirst = () => {
-            return (context) => __awaiter(void 0, void 0, void 0, function* () {
+            return async (context) => {
                 const { root, resolve } = context;
                 const scrollTarget = options.scrollTarget
                     ? resolve(options.scrollTarget, root)
                     : root;
-                const doScroll = () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield scrollTarget.evaluate((el) => {
+                const doScroll = async () => {
+                    await scrollTarget.evaluate((el) => {
                         el.scrollTop = 0;
                         el.scrollLeft = 0;
                     });
-                });
+                };
                 // Stabilization: Wait for content to reset
-                return yield stabilization(context, doScroll);
-            });
+                return await stabilization(context, doScroll);
+            };
         };
         return {
             goNext: createScroller(1),

package/dist/strategies/sorting.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.SortingStrategies = void 0;
 /**
@@ -21,29 +12,25 @@ exports.SortingStrategies = {
      */
     AriaSort: () => {
         return {
-            doSort(_a) {
-                return __awaiter(this, arguments, void 0, function* ({ columnName, direction, context }) {
-                    // getHeaderCell is always present on TableContext after table is initialized
-                    const targetHeader = yield context.getHeaderCell(columnName);
-                    // The table engine handles verify-and-retry. We only provide the trigger here.
-                    yield targetHeader.click();
-                });
+            async doSort({ columnName, direction, context }) {
+                // getHeaderCell is always present on TableContext after table is initialized
+                const targetHeader = await context.getHeaderCell(columnName);
+                // The table engine handles verify-and-retry. We only provide the trigger here.
+                await targetHeader.click();
             },
-            getSortState(_a) {
-                return __awaiter(this, arguments, void 0, function* ({ columnName, context }) {
-                    try {
-                        const targetHeader = yield context.getHeaderCell(columnName);
-                        const ariaSort = yield targetHeader.getAttribute('aria-sort');
-                        if (ariaSort === 'ascending')
-                            return 'asc';
-                        if (ariaSort === 'descending')
-                            return 'desc';
-                        return 'none';
-                    }
-                    catch (_b) {
-                        return 'none'; // Header not found, treat as unsorted
-                    }
-                });
+            async getSortState({ columnName, context }) {
+                try {
+                    const targetHeader = await context.getHeaderCell(columnName);
+                    const ariaSort = await targetHeader.getAttribute('aria-sort');
+                    if (ariaSort === 'ascending')
+                        return 'asc';
+                    if (ariaSort === 'descending')
+                        return 'desc';
+                    return 'none';
+                }
+                catch (_a) {
+                    return 'none'; // Header not found, treat as unsorted
+                }
             },
         };
     },