@rickcedwhat/playwright-smart-table 6.7.4 → 6.7.5

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* () {
+    findRows() {
+        return __awaiter(this, arguments, void 0, function* (filters = {}, options) {
             var _a, _b, _c, _d;
-            const filtersRecord = filters || {};
+            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;

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/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 });

package/dist/plugins/glide.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;
+};