@teleporthq/teleport-plugin-next-data-source 0.40.15

package/dist/cjs/pagination-plugin.js

@@ -0,0 +1,1484 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNextArrayMapperPaginationPlugin = void 0;
+var teleport_types_1 = require("@teleporthq/teleport-types");
+var types = __importStar(require("@babel/types"));
+var array_mapper_pagination_1 = require("./array-mapper-pagination");
+var utils_1 = require("./utils");
+var createNextArrayMapperPaginationPlugin = function () {
+    var paginationPlugin = function (structure) { return __awaiter(void 0, void 0, void 0, function () {
+        var uidl, chunks, dependencies, options, componentChunk, variableDeclaration, declarator, arrowFunction, blockStatement, _a, paginatedMappers, searchOnlyMappers, paginationOnlyMappers, detectedPaginations, detectedSearchOnly, paginationInfos, getStaticPropsChunk, isPage, isComponent, opts, perPageMap, searchConfigMap, queryColumnsMap, hasSearchEnabled, firstReturnIndex, insertIndex, dataSourceToInfos_1, searchOnlyDataSources;
+        var _b, _c, _d;
+        return __generator(this, function (_e) {
+            uidl = structure.uidl, chunks = structure.chunks, dependencies = structure.dependencies, options = structure.options;
+            componentChunk = chunks.find(function (chunk) { return chunk.name === 'jsx-component'; });
+            if (!componentChunk || componentChunk.type !== teleport_types_1.ChunkType.AST) {
+                return [2 /*return*/, structure];
+            }
+            if (!options || !options.dataSources || !options.extractedResources) {
+                return [2 /*return*/, structure];
+            }
+            variableDeclaration = componentChunk.content;
+            if (!variableDeclaration.declarations || variableDeclaration.declarations.length === 0) {
+                return [2 /*return*/, structure];
+            }
+            declarator = variableDeclaration.declarations[0];
+            if (!declarator.init) {
+                return [2 /*return*/, structure];
+            }
+            arrowFunction = declarator.init;
+            if (!arrowFunction.body) {
+                return [2 /*return*/, structure];
+            }
+            blockStatement = arrowFunction.body;
+            _a = detectPaginationsAndSearchFromJSX(blockStatement, uidl.node), paginatedMappers = _a.paginatedMappers, searchOnlyMappers = _a.searchOnlyMappers, paginationOnlyMappers = _a.paginationOnlyMappers;
+            if (paginatedMappers.length === 0 &&
+                searchOnlyMappers.length === 0 &&
+                paginationOnlyMappers.length === 0) {
+                return [2 /*return*/, structure];
+            }
+            detectedPaginations = __spreadArray(__spreadArray([], paginatedMappers, true), paginationOnlyMappers, true);
+            detectedSearchOnly = searchOnlyMappers;
+            if (!dependencies.useState) {
+                dependencies.useState = {
+                    type: 'library',
+                    path: 'react',
+                    version: '',
+                    meta: {
+                        namedImport: true,
+                    },
+                };
+            }
+            if (!dependencies.useMemo) {
+                dependencies.useMemo = {
+                    type: 'library',
+                    path: 'react',
+                    version: '',
+                    meta: {
+                        namedImport: true,
+                    },
+                };
+            }
+            if (!dependencies.useCallback) {
+                dependencies.useCallback = {
+                    type: 'library',
+                    path: 'react',
+                    version: '',
+                    meta: {
+                        namedImport: true,
+                    },
+                };
+            }
+            if (!dependencies.useRef) {
+                dependencies.useRef = {
+                    type: 'library',
+                    path: 'react',
+                    version: '',
+                    meta: {
+                        namedImport: true,
+                    },
+                };
+            }
+            if (!componentChunk.meta) {
+                componentChunk.meta = {};
+            }
+            componentChunk.meta.isClientComponent = true;
+            paginationInfos = [];
+            getStaticPropsChunk = chunks.find(function (chunk) { return chunk.name === 'getStaticProps'; });
+            isPage = !!getStaticPropsChunk;
+            isComponent = !isPage;
+            opts = options;
+            perPageMap = ((_b = opts.paginationConfig) === null || _b === void 0 ? void 0 : _b.perPageMap) || new Map();
+            searchConfigMap = ((_c = opts.paginationConfig) === null || _c === void 0 ? void 0 : _c.searchConfigMap) || new Map();
+            queryColumnsMap = ((_d = opts.paginationConfig) === null || _d === void 0 ? void 0 : _d.queryColumnsMap) || new Map();
+            detectedPaginations.forEach(function (detected, index) {
+                var paginationNodeId = "pg_".concat(index);
+                // Use arrayMapperRenderProp if available, otherwise fall back to dataSourceIdentifier
+                var lookupKey = detected.arrayMapperRenderProp || detected.dataSourceIdentifier;
+                var perPage = perPageMap.get(lookupKey) || 10;
+                var searchConfig = searchConfigMap.get(lookupKey);
+                // queryColumns is keyed by dataSourceIdentifier, not array mapper render prop
+                var queryColumns = queryColumnsMap.get(detected.dataSourceIdentifier);
+                var info = (0, array_mapper_pagination_1.generatePaginationLogic)(paginationNodeId, detected.dataSourceIdentifier, perPage, searchConfig, queryColumns);
+                paginationInfos.push(info);
+                // If both pagination and search are enabled, combine them into a single state object
+                if (info.searchEnabled && info.searchQueryVar && info.setSearchQueryVar) {
+                    // Combined state: { page: 1, debouncedQuery: '' }
+                    var combinedStateVar = "paginationState_pg_".concat(index);
+                    var setCombinedStateVar = "setPaginationState_pg_".concat(index);
+                    var combinedStateAST = types.variableDeclaration('const', [
+                        types.variableDeclarator(types.arrayPattern([
+                            types.identifier(combinedStateVar),
+                            types.identifier(setCombinedStateVar),
+                        ]), types.callExpression(types.identifier('useState'), [
+                            types.objectExpression([
+                                types.objectProperty(types.identifier('page'), types.numericLiteral(1)),
+                                types.objectProperty(types.identifier('debouncedQuery'), types.stringLiteral('')),
+                            ]),
+                        ])),
+                    ]);
+                    blockStatement.body.unshift(combinedStateAST);
+                    // Still need the immediate search query state for the input
+                    var searchStateAST = types.variableDeclaration('const', [
+                        types.variableDeclarator(types.arrayPattern([
+                            types.identifier(info.searchQueryVar),
+                            types.identifier(info.setSearchQueryVar),
+                        ]), types.callExpression(types.identifier('useState'), [types.stringLiteral('')])),
+                    ]);
+                    blockStatement.body.unshift(searchStateAST);
+                    info.combinedStateVar = combinedStateVar;
+                    info.setCombinedStateVar = setCombinedStateVar;
+                }
+                else {
+                    // If search is not enabled, just add regular page state
+                    var pageStateAST = types.variableDeclaration('const', [
+                        types.variableDeclarator(types.arrayPattern([
+                            types.identifier(info.pageStateVar),
+                            types.identifier(info.setPageStateVar),
+                        ]), types.callExpression(types.identifier('useState'), [types.numericLiteral(1)])),
+                    ]);
+                    blockStatement.body.unshift(pageStateAST);
+                }
+                // Add maxPages state
+                var maxPagesStateVar = "".concat(info.pageStateVar.replace('_page', ''), "_maxPages");
+                var setMaxPagesStateVar = "set".concat(maxPagesStateVar.charAt(0).toUpperCase() + maxPagesStateVar.slice(1));
+                // For pages: initialize from props (with pagination-specific prop name), for components: initialize to 0
+                var maxPagesInitValue = isPage
+                    ? types.logicalExpression('||', types.optionalMemberExpression(types.identifier('props'), types.identifier("".concat(info.dataSourceIdentifier, "_pg_").concat(index, "_maxPages")), false, true), types.numericLiteral(0))
+                    : types.numericLiteral(0);
+                var maxPagesStateAST = types.variableDeclaration('const', [
+                    types.variableDeclarator(types.arrayPattern([
+                        types.identifier(maxPagesStateVar),
+                        types.identifier(setMaxPagesStateVar),
+                    ]), types.callExpression(types.identifier('useState'), [maxPagesInitValue])),
+                ]);
+                blockStatement.body.unshift(maxPagesStateAST);
+                info.maxPagesStateVar = maxPagesStateVar;
+                info.setMaxPagesStateVar = setMaxPagesStateVar;
+                // Add refs to track first render for each useEffect
+                if (info.searchEnabled) {
+                    var skipDebounceOnMountRefVar = "skipDebounceOnMount_pg_".concat(index);
+                    var skipDebounceRefAST = types.variableDeclaration('const', [
+                        types.variableDeclarator(types.identifier(skipDebounceOnMountRefVar), types.callExpression(types.identifier('useRef'), [types.booleanLiteral(true)])),
+                    ]);
+                    blockStatement.body.unshift(skipDebounceRefAST);
+                    info.skipDebounceOnMountRefVar = skipDebounceOnMountRefVar;
+                    var skipCountFetchOnMountRefVar = "skipCountFetchOnMount_pg_".concat(index);
+                    var skipCountFetchRefAST = types.variableDeclaration('const', [
+                        types.variableDeclarator(types.identifier(skipCountFetchOnMountRefVar), types.callExpression(types.identifier('useRef'), [types.booleanLiteral(true)])),
+                    ]);
+                    blockStatement.body.unshift(skipCountFetchRefAST);
+                    info.skipCountFetchOnMountRefVar = skipCountFetchOnMountRefVar;
+                }
+            });
+            hasSearchEnabled = paginationInfos.some(function (info) { return info.searchEnabled; });
+            if (hasSearchEnabled && !dependencies.useEffect) {
+                dependencies.useEffect = {
+                    type: 'library',
+                    path: 'react',
+                    version: '',
+                    meta: {
+                        namedImport: true,
+                    },
+                };
+            }
+            firstReturnIndex = blockStatement.body.findIndex(function (stmt) { return stmt.type === 'ReturnStatement'; });
+            insertIndex = firstReturnIndex !== -1 ? firstReturnIndex : blockStatement.body.length;
+            // Add effects in reverse order so they appear in correct order
+            paginationInfos.forEach(function (info) {
+                if (info.searchEnabled &&
+                    info.searchQueryVar &&
+                    info.debouncedSearchQueryVar &&
+                    info.setDebouncedSearchQueryVar) {
+                    // Add effect that updates debounced search after delay
+                    var skipDebounceOnMountRefVar = info.skipDebounceOnMountRefVar;
+                    var setCombinedStateVar = info.setCombinedStateVar;
+                    var debounceEffect = types.expressionStatement(types.callExpression(types.identifier('useEffect'), [
+                        types.arrowFunctionExpression([], types.blockStatement([
+                            types.ifStatement(types.memberExpression(types.identifier(skipDebounceOnMountRefVar), types.identifier('current')), types.blockStatement([
+                                types.expressionStatement(types.assignmentExpression('=', types.memberExpression(types.identifier(skipDebounceOnMountRefVar), types.identifier('current')), types.booleanLiteral(false))),
+                                types.returnStatement(),
+                            ])),
+                            types.variableDeclaration('const', [
+                                types.variableDeclarator(types.identifier('timer'), types.callExpression(types.identifier('setTimeout'), [
+                                    types.arrowFunctionExpression([], types.blockStatement([
+                                        types.expressionStatement(types.callExpression(types.identifier(setCombinedStateVar), [
+                                            types.objectExpression([
+                                                types.objectProperty(types.identifier('page'), types.numericLiteral(1)),
+                                                types.objectProperty(types.identifier('debouncedQuery'), types.identifier(info.searchQueryVar)),
+                                            ]),
+                                        ])),
+                                    ])),
+                                    types.numericLiteral(info.searchDebounce || 300),
+                                ])),
+                            ]),
+                            types.returnStatement(types.arrowFunctionExpression([], types.callExpression(types.identifier('clearTimeout'), [
+                                types.identifier('timer'),
+                            ]))),
+                        ])),
+                        types.arrayExpression([types.identifier(info.searchQueryVar)]),
+                    ]));
+                    blockStatement.body.splice(insertIndex, 0, debounceEffect);
+                    // Add useEffect to refetch count when search changes (for both pages and components)
+                    if (info.queryColumns && info.queryColumns.length > 0) {
+                        var detected = detectedPaginations.find(function (d) { return d.dataSourceIdentifier === info.dataSourceIdentifier; });
+                        if (!detected) {
+                            return;
+                        }
+                        var resourceDefAttr = detected.dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'resourceDefinition'; });
+                        if (resourceDefAttr &&
+                            resourceDefAttr.value &&
+                            resourceDefAttr.value.type === 'JSXExpressionContainer') {
+                            var resourceDef = resourceDefAttr.value.expression;
+                            if (resourceDef.type === 'ObjectExpression') {
+                                var dataSourceIdProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'dataSourceId'; });
+                                var tableNameProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'tableName'; });
+                                var dataSourceTypeProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'dataSourceType'; });
+                                if (dataSourceIdProp && tableNameProp && dataSourceTypeProp) {
+                                    var dataSourceId = dataSourceIdProp.value.value;
+                                    var tableName = tableNameProp.value.value;
+                                    var dataSourceType = dataSourceTypeProp.value.value;
+                                    var fileName = "".concat(dataSourceType, "-").concat(tableName, "-").concat(dataSourceId.substring(0, 8));
+                                    var setMaxPagesStateVar = info.setMaxPagesStateVar;
+                                    // Create useEffect to refetch count when debounced search changes
+                                    var skipCountFetchOnMountRefVar = info.skipCountFetchOnMountRefVar;
+                                    var combinedStateVar = info.combinedStateVar;
+                                    var refetchCountEffect = types.expressionStatement(types.callExpression(types.identifier('useEffect'), [
+                                        types.arrowFunctionExpression([], types.blockStatement([
+                                            types.ifStatement(types.memberExpression(types.identifier(skipCountFetchOnMountRefVar), types.identifier('current')), types.blockStatement([
+                                                types.expressionStatement(types.assignmentExpression('=', types.memberExpression(types.identifier(skipCountFetchOnMountRefVar), types.identifier('current')), types.booleanLiteral(false))),
+                                                types.returnStatement(),
+                                            ])),
+                                            types.expressionStatement(types.callExpression(types.memberExpression(types.callExpression(types.memberExpression(types.callExpression(types.identifier('fetch'), [
+                                                types.templateLiteral([
+                                                    types.templateElement({
+                                                        raw: "/api/".concat(fileName, "-count?"),
+                                                        cooked: "/api/".concat(fileName, "-count?"),
+                                                    }),
+                                                    types.templateElement({ raw: '', cooked: '' }),
+                                                ], [
+                                                    types.newExpression(types.identifier('URLSearchParams'), [
+                                                        types.objectExpression([
+                                                            types.objectProperty(types.identifier('query'), types.memberExpression(types.identifier(combinedStateVar), types.identifier('debouncedQuery'))),
+                                                            types.objectProperty(types.identifier('queryColumns'), types.callExpression(types.memberExpression(types.identifier('JSON'), types.identifier('stringify')), [
+                                                                types.arrayExpression(info.queryColumns.map(function (col) {
+                                                                    return types.stringLiteral(col);
+                                                                })),
+                                                            ])),
+                                                        ]),
+                                                    ]),
+                                                ]),
+                                            ]), types.identifier('then')), [
+                                                types.arrowFunctionExpression([types.identifier('res')], types.callExpression(types.memberExpression(types.identifier('res'), types.identifier('json')), [])),
+                                            ]), types.identifier('then')), [
+                                                types.arrowFunctionExpression([types.identifier('data')], types.blockStatement([
+                                                    types.ifStatement(types.logicalExpression('&&', types.identifier('data'), types.binaryExpression('in', types.stringLiteral('count'), types.identifier('data'))), types.blockStatement([
+                                                        types.expressionStatement(types.callExpression(types.identifier(setMaxPagesStateVar), [
+                                                            types.conditionalExpression(types.binaryExpression('===', types.memberExpression(types.identifier('data'), types.identifier('count')), types.numericLiteral(0)), types.numericLiteral(0), types.callExpression(types.memberExpression(types.identifier('Math'), types.identifier('ceil')), [
+                                                                types.binaryExpression('/', types.memberExpression(types.identifier('data'), types.identifier('count')), types.numericLiteral(info.perPage)),
+                                                            ])),
+                                                        ])),
+                                                    ])),
+                                                ])),
+                                            ])),
+                                        ])),
+                                        types.arrayExpression([
+                                            types.memberExpression(types.identifier(combinedStateVar), types.identifier('debouncedQuery')),
+                                        ]),
+                                    ]));
+                                    blockStatement.body.splice(insertIndex, 0, refetchCountEffect);
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // For components, add useEffect to fetch count on mount
+            if (isComponent) {
+                if (!dependencies.useEffect) {
+                    dependencies.useEffect = {
+                        type: 'library',
+                        path: 'react',
+                        version: '',
+                        meta: {
+                            namedImport: true,
+                        },
+                    };
+                }
+                dataSourceToInfos_1 = new Map();
+                paginationInfos.forEach(function (info) {
+                    var detected = detectedPaginations.find(function (d) { return d.dataSourceIdentifier === info.dataSourceIdentifier; });
+                    if (!detected) {
+                        return;
+                    }
+                    var resourceDefAttr = detected.dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'resourceDefinition'; });
+                    if (!resourceDefAttr ||
+                        !resourceDefAttr.value ||
+                        resourceDefAttr.value.type !== 'JSXExpressionContainer') {
+                        return;
+                    }
+                    var resourceDef = resourceDefAttr.value.expression;
+                    if (resourceDef.type !== 'ObjectExpression') {
+                        return;
+                    }
+                    var dataSourceIdProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'dataSourceId'; });
+                    var tableNameProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'tableName'; });
+                    var dataSourceTypeProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'dataSourceType'; });
+                    if (!dataSourceIdProp || !tableNameProp || !dataSourceTypeProp) {
+                        return;
+                    }
+                    var dataSourceId = dataSourceIdProp.value.value;
+                    var tableName = tableNameProp.value.value;
+                    var dataSourceType = dataSourceTypeProp.value.value;
+                    var fileName = "".concat(dataSourceType, "-").concat(tableName, "-").concat(dataSourceId.substring(0, 8));
+                    // Group by data source identifier
+                    if (!dataSourceToInfos_1.has(info.dataSourceIdentifier)) {
+                        dataSourceToInfos_1.set(info.dataSourceIdentifier, []);
+                    }
+                    dataSourceToInfos_1.get(info.dataSourceIdentifier).push({ info: info, detected: detected, fileName: fileName });
+                });
+                // Create ONE useEffect per unique data source
+                dataSourceToInfos_1.forEach(function (infos) {
+                    var fileName = infos[0].fileName;
+                    // Create array of setState calls - one for each pagination using this data source
+                    var setStateStatements = infos.map(function (_a) {
+                        var info = _a.info;
+                        var setMaxPagesStateVar = info.setMaxPagesStateVar;
+                        return types.expressionStatement(types.callExpression(types.identifier(setMaxPagesStateVar), [
+                            types.callExpression(types.memberExpression(types.identifier('Math'), types.identifier('ceil')), [
+                                types.binaryExpression('/', types.memberExpression(types.identifier('data'), types.identifier('count')), types.numericLiteral(info.perPage)),
+                            ]),
+                        ]));
+                    });
+                    // Create useEffect to fetch count on mount - sets ALL maxPages for this data source
+                    var useEffectAST = types.expressionStatement(types.callExpression(types.identifier('useEffect'), [
+                        types.arrowFunctionExpression([], types.blockStatement([
+                            types.expressionStatement(types.callExpression(types.memberExpression(types.callExpression(types.memberExpression(types.callExpression(types.identifier('fetch'), [
+                                types.stringLiteral("/api/".concat(fileName, "-count")),
+                            ]), types.identifier('then')), [
+                                types.arrowFunctionExpression([types.identifier('res')], types.callExpression(types.memberExpression(types.identifier('res'), types.identifier('json')), [])),
+                            ]), types.identifier('then')), [
+                                types.arrowFunctionExpression([types.identifier('data')], types.blockStatement([
+                                    types.ifStatement(types.logicalExpression('&&', types.identifier('data'), types.memberExpression(types.identifier('data'), types.identifier('count'))), types.blockStatement(setStateStatements)),
+                                ])),
+                            ])),
+                        ])),
+                        types.arrayExpression([]),
+                    ]));
+                    blockStatement.body.unshift(useEffectAST);
+                });
+            }
+            createAPIRoutesForPaginatedDataSources(uidl.node, options.dataSources, componentChunk, options.extractedResources, paginationInfos, isComponent);
+            detectedPaginations.forEach(function (detected, index) {
+                addPaginationParamsToDataProvider(detected.dataProviderJSX, paginationInfos[index], index);
+            });
+            modifyPaginationButtons(blockStatement, detectedPaginations, paginationInfos);
+            modifySearchInputs(blockStatement, detectedPaginations, paginationInfos);
+            if (isPage) {
+                modifyGetStaticPropsForPagination(chunks, paginationInfos);
+            }
+            searchOnlyDataSources = detectedSearchOnly;
+            if (searchOnlyDataSources.length > 0) {
+                handleSearchOnlyArrayMappers(blockStatement, searchOnlyDataSources, searchConfigMap, queryColumnsMap, insertIndex, dependencies);
+                // Create API routes for search-only data sources
+                createAPIRoutesForSearchOnlyDataSources(uidl.node, options.dataSources, componentChunk, options.extractedResources, searchOnlyDataSources);
+            }
+            return [2 /*return*/, structure];
+        });
+    }); };
+    return paginationPlugin;
+};
+exports.createNextArrayMapperPaginationPlugin = createNextArrayMapperPaginationPlugin;
+function detectPaginationsAndSearchFromJSX(blockStatement, uidlNode) {
+    var dataProviderMap = new Map();
+    var arrayMapperInfoMap = new Map();
+    if (uidlNode) {
+        var collectArrayMapperInfo_1 = function (node) {
+            var _a, _b, _c, _d, _e;
+            if (!node) {
+                return;
+            }
+            if (node.type === 'data-source-list' && ((_a = node.content) === null || _a === void 0 ? void 0 : _a.renderPropIdentifier)) {
+                var dataSourceIdentifier_1 = node.content.renderPropIdentifier;
+                if ((_d = (_c = (_b = node.content.nodes) === null || _b === void 0 ? void 0 : _b.success) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.children) {
+                    node.content.nodes.success.content.children.forEach(function (child) {
+                        var _a;
+                        if (child.type === 'cms-list-repeater' && ((_a = child.content) === null || _a === void 0 ? void 0 : _a.renderPropIdentifier)) {
+                            var arrayMapperRenderProp = child.content.renderPropIdentifier;
+                            // Key by array mapper render prop (unique), not data source identifier
+                            arrayMapperInfoMap.set(arrayMapperRenderProp, {
+                                dataSourceIdentifier: dataSourceIdentifier_1,
+                                renderProp: arrayMapperRenderProp,
+                                paginated: child.content.paginated || false,
+                                searchEnabled: child.content.searchEnabled || false,
+                            });
+                        }
+                    });
+                }
+            }
+            if ((_e = node.content) === null || _e === void 0 ? void 0 : _e.children) {
+                node.content.children.forEach(function (child) { return collectArrayMapperInfo_1(child); });
+            }
+            if (node.children && Array.isArray(node.children)) {
+                node.children.forEach(function (child) { return collectArrayMapperInfo_1(child); });
+            }
+        };
+        collectArrayMapperInfo_1(uidlNode);
+    }
+    var dataProvidersWithParents = [];
+    var findDataProvidersAndParents = function (node, parent) {
+        var _a, _b;
+        if (parent === void 0) { parent = null; }
+        if (!node) {
+            return;
+        }
+        // Check if this is a DataProvider
+        if (node.type === 'JSXElement' && ((_b = (_a = node.openingElement) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.name) === 'DataProvider') {
+            dataProvidersWithParents.push({
+                dataProvider: node,
+                parent: parent,
+            });
+        }
+        // Only recurse through JSX structure, not into embedded expressions or code
+        if (node.type === 'ReturnStatement' && node.argument) {
+            findDataProvidersAndParents(node.argument, parent);
+        }
+        else if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+            // Recurse through JSX children
+            if (node.children && Array.isArray(node.children)) {
+                node.children.forEach(function (child) { return findDataProvidersAndParents(child, node); });
+            }
+        }
+        else if (node.type === 'JSXExpressionContainer') {
+            // For expression containers, continue but don't go into the expression itself
+            if (node.expression &&
+                (node.expression.type === 'JSXElement' || node.expression.type === 'JSXFragment')) {
+                findDataProvidersAndParents(node.expression, parent);
+            }
+        }
+        else if (node.type === 'BlockStatement') {
+            // For block statements (function bodies), look through body array
+            if (node.body && Array.isArray(node.body)) {
+                node.body.forEach(function (stmt) { return findDataProvidersAndParents(stmt, node); });
+            }
+        }
+        else if (node.type === 'ConditionalExpression') {
+            // Check both branches of conditional
+            findDataProvidersAndParents(node.consequent, parent);
+            findDataProvidersAndParents(node.alternate, parent);
+        }
+    };
+    findDataProvidersAndParents(blockStatement);
+    // Now process each DataProvider and find its siblings
+    dataProvidersWithParents.forEach(function (_a) {
+        var _b, _c;
+        var dataProvider = _a.dataProvider, parent = _a.parent;
+        var nameAttr = dataProvider.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'name'; });
+        // Find the array mapper render prop by looking inside renderSuccess -> Repeater -> renderItem param
+        var renderSuccessAttr = dataProvider.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'renderSuccess'; });
+        var arrayMapperRenderProp;
+        if (renderSuccessAttr && ((_b = renderSuccessAttr.value) === null || _b === void 0 ? void 0 : _b.type) === 'JSXExpressionContainer') {
+            var renderFunc = renderSuccessAttr.value.expression;
+            if (renderFunc.type === 'ArrowFunctionExpression') {
+                // Look for Repeater inside the render function
+                var findRepeater_1 = function (node) {
+                    var _a, _b;
+                    if (!node) {
+                        return null;
+                    }
+                    if (node.type === 'JSXElement' && ((_b = (_a = node.openingElement) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.name) === 'Repeater') {
+                        return node;
+                    }
+                    if (node.body) {
+                        return findRepeater_1(node.body);
+                    }
+                    if (node.children && Array.isArray(node.children)) {
+                        for (var _i = 0, _c = node.children; _i < _c.length; _i++) {
+                            var child = _c[_i];
+                            var result = findRepeater_1(child);
+                            if (result) {
+                                return result;
+                            }
+                        }
+                    }
+                    if (node.type === 'JSXFragment' || node.type === 'JSXElement') {
+                        if (node.children && Array.isArray(node.children)) {
+                            for (var _d = 0, _e = node.children; _d < _e.length; _d++) {
+                                var child = _e[_d];
+                                var result = findRepeater_1(child);
+                                if (result) {
+                                    return result;
+                                }
+                            }
+                        }
+                    }
+                    if (node.type === 'JSXExpressionContainer') {
+                        return findRepeater_1(node.expression);
+                    }
+                    if (node.expression) {
+                        return findRepeater_1(node.expression);
+                    }
+                    if (node.consequent) {
+                        var result = findRepeater_1(node.consequent);
+                        if (result) {
+                            return result;
+                        }
+                    }
+                    if (node.alternate) {
+                        return findRepeater_1(node.alternate);
+                    }
+                    return null;
+                };
+                var repeater = findRepeater_1(renderFunc);
+                if (repeater) {
+                    // Find renderItem attribute on Repeater
+                    var renderItemAttr = repeater.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'renderItem'; });
+                    if (renderItemAttr && ((_c = renderItemAttr.value) === null || _c === void 0 ? void 0 : _c.type) === 'JSXExpressionContainer') {
+                        var renderItemFunc = renderItemAttr.value.expression;
+                        if (renderItemFunc.type === 'ArrowFunctionExpression' &&
+                            renderItemFunc.params &&
+                            renderItemFunc.params.length > 0) {
+                            var param = renderItemFunc.params[0];
+                            if (param.type === 'Identifier') {
+                                arrayMapperRenderProp = param.name;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (!nameAttr ||
+            !nameAttr.value ||
+            nameAttr.value.type !== 'JSXExpressionContainer' ||
+            !arrayMapperRenderProp) {
+            return;
+        }
+        var dataProviderIdentifier = nameAttr.value.expression.value;
+        var paginationNodeInfo = null;
+        var searchInputInfo = null;
+        // Look through parent's children for siblings
+        if (parent && parent.children && Array.isArray(parent.children)) {
+            parent.children.forEach(function (sibling) {
+                var _a, _b, _c;
+                if (sibling === dataProvider) {
+                    return;
+                }
+                if (sibling.type === 'JSXElement') {
+                    var siblingClassName = getClassName(((_a = sibling.openingElement) === null || _a === void 0 ? void 0 : _a.attributes) || []);
+                    var siblingElementName = (_c = (_b = sibling.openingElement) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.name;
+                    // Found pagination node
+                    if (siblingClassName && siblingClassName.includes('cms-pagination-node')) {
+                        var prevClass = findChildWithClass(sibling, 'previous');
+                        var nextClass = findChildWithClass(sibling, 'next');
+                        if (prevClass || nextClass) {
+                            paginationNodeInfo = {
+                                class: siblingClassName,
+                                prevClass: prevClass,
+                                nextClass: nextClass,
+                            };
+                        }
+                    }
+                    // Found search container - search for input inside it
+                    if (siblingClassName && siblingClassName.includes('data-source-search-node')) {
+                        if (sibling.children && Array.isArray(sibling.children)) {
+                            sibling.children.forEach(function (searchChild) {
+                                var _a, _b, _c;
+                                if (searchChild.type === 'JSXElement') {
+                                    var searchChildElementName = (_b = (_a = searchChild.openingElement) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.name;
+                                    var searchChildClassName = getClassName(((_c = searchChild.openingElement) === null || _c === void 0 ? void 0 : _c.attributes) || []);
+                                    if (searchChildClassName &&
+                                        searchChildClassName.includes('search-input') &&
+                                        searchChildElementName === 'input') {
+                                        searchInputInfo = {
+                                            class: searchChildClassName,
+                                            jsx: searchChild,
+                                        };
+                                    }
+                                }
+                            });
+                        }
+                    }
+                    // Also check if search input is a direct sibling
+                    if (siblingClassName &&
+                        siblingClassName.includes('search-input') &&
+                        siblingElementName === 'input') {
+                        searchInputInfo = {
+                            class: siblingClassName,
+                            jsx: sibling,
+                        };
+                    }
+                }
+            });
+        }
+        // Record the DataProvider with its pagination/search info
+        var uniqueKey = "".concat(dataProviderIdentifier, "__").concat(arrayMapperRenderProp);
+        dataProviderMap.set(uniqueKey, {
+            identifier: dataProviderIdentifier,
+            dataProvider: dataProvider,
+            arrayMapperRenderProp: arrayMapperRenderProp,
+            paginationNode: paginationNodeInfo || undefined,
+            searchInput: searchInputInfo || undefined,
+            hasPagination: !!paginationNodeInfo,
+            hasSearch: !!searchInputInfo,
+        });
+    });
+    // Categorize data providers
+    var paginatedMappers = [];
+    var searchOnlyMappers = [];
+    var paginationOnlyMappers = [];
+    var plainMappers = [];
+    dataProviderMap.forEach(function (info) {
+        var _a, _b, _c, _d;
+        if (info.hasPagination && info.hasSearch) {
+            // Pagination + Search
+            paginatedMappers.push({
+                paginationNodeClass: info.paginationNode.class,
+                prevButtonClass: info.paginationNode.prevClass,
+                nextButtonClass: info.paginationNode.nextClass,
+                dataSourceIdentifier: info.identifier,
+                dataProviderJSX: info.dataProvider,
+                arrayMapperRenderProp: info.arrayMapperRenderProp,
+                searchInputClass: (_a = info.searchInput) === null || _a === void 0 ? void 0 : _a.class,
+                searchInputJSX: (_b = info.searchInput) === null || _b === void 0 ? void 0 : _b.jsx,
+            });
+        }
+        else if (info.hasPagination && !info.hasSearch) {
+            // Pagination only
+            paginationOnlyMappers.push({
+                paginationNodeClass: info.paginationNode.class,
+                prevButtonClass: info.paginationNode.prevClass,
+                nextButtonClass: info.paginationNode.nextClass,
+                dataSourceIdentifier: info.identifier,
+                dataProviderJSX: info.dataProvider,
+                arrayMapperRenderProp: info.arrayMapperRenderProp,
+                searchInputClass: undefined,
+                searchInputJSX: undefined,
+            });
+        }
+        else if (!info.hasPagination && info.hasSearch) {
+            // Search only
+            searchOnlyMappers.push({
+                paginationNodeClass: '',
+                prevButtonClass: null,
+                nextButtonClass: null,
+                dataSourceIdentifier: info.identifier,
+                dataProviderJSX: info.dataProvider,
+                arrayMapperRenderProp: info.arrayMapperRenderProp,
+                searchInputClass: (_c = info.searchInput) === null || _c === void 0 ? void 0 : _c.class,
+                searchInputJSX: (_d = info.searchInput) === null || _d === void 0 ? void 0 : _d.jsx,
+            });
+        }
+        else {
+            // Plain (no pagination, no search)
+            plainMappers.push({
+                paginationNodeClass: '',
+                prevButtonClass: null,
+                nextButtonClass: null,
+                dataSourceIdentifier: info.identifier,
+                dataProviderJSX: info.dataProvider,
+                arrayMapperRenderProp: info.arrayMapperRenderProp,
+                searchInputClass: undefined,
+                searchInputJSX: undefined,
+            });
+        }
+    });
+    return { paginatedMappers: paginatedMappers, searchOnlyMappers: searchOnlyMappers, paginationOnlyMappers: paginationOnlyMappers, plainMappers: plainMappers };
+}
+function handleSearchOnlyArrayMappers(blockStatement, searchOnlyDataSources, searchConfigMap, queryColumnsMap, insertIndex, dependencies) {
+    searchOnlyDataSources.forEach(function (detected, index) {
+        var searchId = "search_".concat(index);
+        var searchQueryVar = "".concat(searchId, "_query");
+        var setSearchQueryVar = "set".concat(searchQueryVar.charAt(0).toUpperCase() + searchQueryVar.slice(1));
+        var debouncedSearchQueryVar = "debounced".concat(searchQueryVar.charAt(0).toUpperCase() + searchQueryVar.slice(1));
+        var setDebouncedSearchQueryVar = "set".concat(debouncedSearchQueryVar.charAt(0).toUpperCase() + debouncedSearchQueryVar.slice(1));
+        var skipDebounceOnMountRefVar = "skipDebounceOnMount".concat(searchId);
+        var searchConfig = searchConfigMap.get(detected.dataSourceIdentifier);
+        var searchDebounce = (searchConfig === null || searchConfig === void 0 ? void 0 : searchConfig.searchDebounce) || 300;
+        var queryColumns = queryColumnsMap.get(detected.dataSourceIdentifier);
+        // Add search query state
+        var searchStateAST = types.variableDeclaration('const', [
+            types.variableDeclarator(types.arrayPattern([types.identifier(searchQueryVar), types.identifier(setSearchQueryVar)]), types.callExpression(types.identifier('useState'), [types.stringLiteral('')])),
+        ]);
+        blockStatement.body.unshift(searchStateAST);
+        // Add debounced search state
+        var debouncedSearchStateAST = types.variableDeclaration('const', [
+            types.variableDeclarator(types.arrayPattern([
+                types.identifier(debouncedSearchQueryVar),
+                types.identifier(setDebouncedSearchQueryVar),
+            ]), types.callExpression(types.identifier('useState'), [types.stringLiteral('')])),
+        ]);
+        blockStatement.body.unshift(debouncedSearchStateAST);
+        // Add skip ref
+        var skipRefAST = types.variableDeclaration('const', [
+            types.variableDeclarator(types.identifier(skipDebounceOnMountRefVar), types.callExpression(types.identifier('useRef'), [types.booleanLiteral(true)])),
+        ]);
+        blockStatement.body.unshift(skipRefAST);
+        // Add useEffect for debouncing
+        if (!dependencies.useEffect) {
+            dependencies.useEffect = {
+                type: 'library',
+                path: 'react',
+                version: '',
+                meta: {
+                    namedImport: true,
+                },
+            };
+        }
+        var debounceEffect = types.expressionStatement(types.callExpression(types.identifier('useEffect'), [
+            types.arrowFunctionExpression([], types.blockStatement([
+                types.ifStatement(types.memberExpression(types.identifier(skipDebounceOnMountRefVar), types.identifier('current')), types.blockStatement([
+                    types.expressionStatement(types.assignmentExpression('=', types.memberExpression(types.identifier(skipDebounceOnMountRefVar), types.identifier('current')), types.booleanLiteral(false))),
+                    types.returnStatement(),
+                ])),
+                types.variableDeclaration('const', [
+                    types.variableDeclarator(types.identifier('timer'), types.callExpression(types.identifier('setTimeout'), [
+                        types.arrowFunctionExpression([], types.blockStatement([
+                            types.expressionStatement(types.callExpression(types.identifier(setDebouncedSearchQueryVar), [
+                                types.identifier(searchQueryVar),
+                            ])),
+                        ])),
+                        types.numericLiteral(searchDebounce),
+                    ])),
+                ]),
+                types.returnStatement(types.arrowFunctionExpression([], types.callExpression(types.identifier('clearTimeout'), [types.identifier('timer')]))),
+            ])),
+            types.arrayExpression([types.identifier(searchQueryVar)]),
+        ]));
+        blockStatement.body.splice(insertIndex, 0, debounceEffect);
+        // Modify DataProvider to include search params (even without queryColumns)
+        if (detected.dataProviderJSX) {
+            addSearchParamsToDataProvider(detected.dataProviderJSX, {
+                debouncedSearchQueryVar: debouncedSearchQueryVar,
+                queryColumns: queryColumns || [],
+            });
+        }
+        // Modify search input
+        if (detected.searchInputJSX) {
+            addSearchInputHandlers(detected.searchInputJSX, {
+                searchQueryVar: searchQueryVar,
+                setSearchQueryVar: setSearchQueryVar,
+                searchEnabled: true,
+            });
+        }
+    });
+}
+function addSearchParamsToDataProvider(dataProviderJSX, config) {
+    var _a, _b;
+    if (!dataProviderJSX || !dataProviderJSX.openingElement) {
+        return;
+    }
+    var debouncedSearchQueryVar = config.debouncedSearchQueryVar, queryColumns = config.queryColumns;
+    // 1. Update params to be wrapped in useMemo
+    var existingParamsAttr = dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'params'; });
+    if (existingParamsAttr && ((_a = existingParamsAttr.value) === null || _a === void 0 ? void 0 : _a.type) === 'JSXExpressionContainer') {
+        var paramsObj = existingParamsAttr.value.expression;
+        if (paramsObj.type === 'ObjectExpression') {
+            // Add query to existing params properties
+            paramsObj.properties.push(types.objectProperty(types.identifier('query'), types.identifier(debouncedSearchQueryVar)));
+            // Add queryColumns only if they exist
+            if (queryColumns.length > 0) {
+                paramsObj.properties.push(types.objectProperty(types.identifier('queryColumns'), types.callExpression(types.memberExpression(types.identifier('JSON'), types.identifier('stringify')), [types.arrayExpression(queryColumns.map(function (col) { return types.stringLiteral(col); }))])));
+            }
+            // Wrap in useMemo with debouncedSearchQueryVar as dependency
+            var memoizedParamsValue = types.callExpression(types.identifier('useMemo'), [
+                types.arrowFunctionExpression([], paramsObj),
+                types.arrayExpression([types.identifier(debouncedSearchQueryVar)]),
+            ]);
+            existingParamsAttr.value.expression = memoizedParamsValue;
+        }
+    }
+    // 2. Update initialData to be conditional on empty search
+    var existingInitialDataAttr = dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'initialData'; });
+    if (existingInitialDataAttr && ((_b = existingInitialDataAttr.value) === null || _b === void 0 ? void 0 : _b.type) === 'JSXExpressionContainer') {
+        var currentInitialData = existingInitialDataAttr.value.expression;
+        // Make it conditional: only use initialData if search is empty
+        existingInitialDataAttr.value.expression = types.conditionalExpression(types.unaryExpression('!', types.identifier(debouncedSearchQueryVar), true), currentInitialData, types.identifier('undefined'));
+    }
+    // 3. Update key to include search query
+    var existingKeyAttr = dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'key'; });
+    var keyExpression = types.templateLiteral([
+        types.templateElement({ raw: 'search-', cooked: 'search-' }),
+        types.templateElement({ raw: '', cooked: '' }),
+    ], [types.identifier(debouncedSearchQueryVar)]);
+    var keyAttr = types.jsxAttribute(types.jsxIdentifier('key'), types.jsxExpressionContainer(keyExpression));
+    if (existingKeyAttr) {
+        var index = dataProviderJSX.openingElement.attributes.indexOf(existingKeyAttr);
+        dataProviderJSX.openingElement.attributes[index] = keyAttr;
+    }
+    else {
+        dataProviderJSX.openingElement.attributes.push(keyAttr);
+    }
+}
+function addPaginationParamsToDataProvider(dataProviderJSX, info, paginationIndex) {
+    var _a;
+    if (!dataProviderJSX || !dataProviderJSX.openingElement) {
+        return;
+    }
+    var combinedStateVar = info.combinedStateVar;
+    var paramsProperties;
+    var dependencies;
+    if (info.searchEnabled && combinedStateVar) {
+        // Use combined state for both page and query
+        paramsProperties = [
+            types.objectProperty(types.identifier('page'), types.memberExpression(types.identifier(combinedStateVar), types.identifier('page'))),
+            types.objectProperty(types.identifier('perPage'), types.numericLiteral(info.perPage)),
+            types.objectProperty(types.identifier('query'), types.memberExpression(types.identifier(combinedStateVar), types.identifier('debouncedQuery'))),
+        ];
+        if (info.queryColumns && info.queryColumns.length > 0) {
+            paramsProperties.push(types.objectProperty(types.identifier('queryColumns'), types.callExpression(types.memberExpression(types.identifier('JSON'), types.identifier('stringify')), [types.arrayExpression(info.queryColumns.map(function (col) { return types.stringLiteral(col); }))])));
+        }
+        // Single dependency: the combined state object
+        dependencies = [types.identifier(combinedStateVar)];
+    }
+    else {
+        // Pagination only (no search)
+        paramsProperties = [
+            types.objectProperty(types.identifier('page'), types.identifier(info.pageStateVar)),
+            types.objectProperty(types.identifier('perPage'), types.numericLiteral(info.perPage)),
+        ];
+        dependencies = [types.identifier(info.pageStateVar)];
+    }
+    // Wrap params in useMemo to prevent unnecessary refetches
+    var memoizedParamsValue = types.callExpression(types.identifier('useMemo'), [
+        types.arrowFunctionExpression([], types.objectExpression(paramsProperties)),
+        types.arrayExpression(dependencies),
+    ]);
+    var paramsAttr = types.jsxAttribute(types.jsxIdentifier('params'), types.jsxExpressionContainer(memoizedParamsValue));
+    var existingParamsAttr = dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'params'; });
+    if (existingParamsAttr) {
+        var index = dataProviderJSX.openingElement.attributes.indexOf(existingParamsAttr);
+        dataProviderJSX.openingElement.attributes[index] = paramsAttr;
+    }
+    else {
+        dataProviderJSX.openingElement.attributes.push(paramsAttr);
+    }
+    var existingInitialDataAttr = dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'initialData'; });
+    if (existingInitialDataAttr && existingInitialDataAttr.value) {
+        // Update initialData to use the paginated prop name
+        var paginatedPropName = "".concat(info.dataSourceIdentifier, "_pg_").concat(paginationIndex);
+        // If search is enabled, use combined state; otherwise use page state
+        var condition = void 0;
+        if (info.searchEnabled && combinedStateVar) {
+            condition = types.logicalExpression('&&', types.binaryExpression('===', types.memberExpression(types.identifier(combinedStateVar), types.identifier('page')), types.numericLiteral(1)), types.unaryExpression('!', types.memberExpression(types.identifier(combinedStateVar), types.identifier('debouncedQuery')), true));
+        }
+        else {
+            condition = types.binaryExpression('===', types.identifier(info.pageStateVar), types.numericLiteral(1));
+        }
+        existingInitialDataAttr.value.expression = types.conditionalExpression(condition, types.optionalMemberExpression(types.identifier('props'), types.identifier(paginatedPropName), false, true), types.identifier('undefined'));
+    }
+    var existingKeyAttr = dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'key'; });
+    // Include page and search in key to trigger refetch when they change
+    var keyExpression;
+    if (info.searchEnabled && combinedStateVar) {
+        keyExpression = types.templateLiteral([
+            types.templateElement({
+                raw: "".concat(info.dataSourceIdentifier, "-page-"),
+                cooked: "".concat(info.dataSourceIdentifier, "-page-"),
+            }),
+            types.templateElement({ raw: '-search-', cooked: '-search-' }),
+            types.templateElement({ raw: '', cooked: '' }),
+        ], [
+            types.memberExpression(types.identifier(combinedStateVar), types.identifier('page')),
+            types.memberExpression(types.identifier(combinedStateVar), types.identifier('debouncedQuery')),
+        ]);
+    }
+    else {
+        keyExpression = types.templateLiteral([
+            types.templateElement({
+                raw: "".concat(info.dataSourceIdentifier, "-"),
+                cooked: "".concat(info.dataSourceIdentifier, "-"),
+            }),
+            types.templateElement({ raw: '', cooked: '' }),
+        ], [types.identifier(info.pageStateVar)]);
+    }
+    var keyAttr = types.jsxAttribute(types.jsxIdentifier('key'), types.jsxExpressionContainer(keyExpression));
+    if (existingKeyAttr) {
+        var index = dataProviderJSX.openingElement.attributes.indexOf(existingKeyAttr);
+        dataProviderJSX.openingElement.attributes[index] = keyAttr;
+    }
+    else {
+        dataProviderJSX.openingElement.attributes.push(keyAttr);
+    }
+    // For pagination, always create a fresh fetchData that calls the API route
+    // Get the resource definition to build the API URL
+    var resourceDefAttr = dataProviderJSX.openingElement.attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'resourceDefinition'; });
+    if (resourceDefAttr && ((_a = resourceDefAttr.value) === null || _a === void 0 ? void 0 : _a.type) === 'JSXExpressionContainer') {
+        var resourceDef = resourceDefAttr.value.expression;
+        if (resourceDef.type === 'ObjectExpression') {
+            var dataSourceIdProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'dataSourceId'; });
+            var tableNameProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'tableName'; });
+            var dataSourceTypeProp = resourceDef.properties.find(function (p) { return p.type === 'ObjectProperty' && p.key.value === 'dataSourceType'; });
+            if (dataSourceIdProp && tableNameProp && dataSourceTypeProp) {
+                var dataSourceId = dataSourceIdProp.value.value;
+                var tableName = tableNameProp.value.value;
+                var dataSourceType = dataSourceTypeProp.value.value;
+                var fileName = "".concat(dataSourceType, "-").concat(tableName, "-").concat(dataSourceId.substring(0, 8));
+                // Create fetchData attribute with proper fetch chain wrapped in useCallback
+                var fetchDataValue = types.callExpression(types.identifier('useCallback'), [
+                    types.arrowFunctionExpression([types.identifier('params')], types.callExpression(types.memberExpression(types.callExpression(types.memberExpression(types.callExpression(types.identifier('fetch'), [
+                        types.templateLiteral([
+                            types.templateElement({
+                                raw: "/api/".concat(fileName, "?"),
+                                cooked: "/api/".concat(fileName, "?"),
+                            }),
+                            types.templateElement({ raw: '', cooked: '' }),
+                        ], [
+                            types.newExpression(types.identifier('URLSearchParams'), [
+                                types.identifier('params'),
+                            ]),
+                        ]),
+                        types.objectExpression([
+                            types.objectProperty(types.identifier('headers'), types.objectExpression([
+                                types.objectProperty(types.stringLiteral('Content-Type'), types.stringLiteral('application/json')),
+                            ])),
+                        ]),
+                    ]), types.identifier('then')), [
+                        types.arrowFunctionExpression([types.identifier('res')], types.callExpression(types.memberExpression(types.identifier('res'), types.identifier('json')), [])),
+                    ]), types.identifier('then')), [
+                        types.arrowFunctionExpression([types.identifier('response')], types.optionalMemberExpression(types.identifier('response'), types.identifier('data'), false, true)),
+                    ])),
+                    types.arrayExpression([]),
+                ]);
+                var newFetchDataAttr = types.jsxAttribute(types.jsxIdentifier('fetchData'), types.jsxExpressionContainer(fetchDataValue));
+                // Remove existing fetchData attribute if present
+                var existingFetchDataIndex = dataProviderJSX.openingElement.attributes.findIndex(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'fetchData'; });
+                if (existingFetchDataIndex !== -1) {
+                    dataProviderJSX.openingElement.attributes[existingFetchDataIndex] = newFetchDataAttr;
+                }
+                else {
+                    dataProviderJSX.openingElement.attributes.push(newFetchDataAttr);
+                }
+            }
+        }
+    }
+}
+function findChildWithClass(node, classSubstring) {
+    var _a;
+    if (!node) {
+        return null;
+    }
+    if (node.type === 'JSXElement') {
+        var className = getClassName(((_a = node.openingElement) === null || _a === void 0 ? void 0 : _a.attributes) || []);
+        if (className && className.includes(classSubstring)) {
+            return className;
+        }
+    }
+    if (node.children) {
+        for (var _i = 0, _b = node.children; _i < _b.length; _i++) {
+            var child = _b[_i];
+            var found = findChildWithClass(child, classSubstring);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    if (typeof node === 'object') {
+        for (var _c = 0, _d = Object.values(node); _c < _d.length; _c++) {
+            var value = _d[_c];
+            if (Array.isArray(value)) {
+                for (var _e = 0, value_1 = value; _e < value_1.length; _e++) {
+                    var item = value_1[_e];
+                    var found = findChildWithClass(item, classSubstring);
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+            else if (typeof value === 'object') {
+                var found = findChildWithClass(value, classSubstring);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+    }
+    return null;
+}
+function modifyPaginationButtons(blockStatement, detectedPaginations, paginationInfos) {
+    var modifyNode = function (node) {
+        if (!node) {
+            return;
+        }
+        if (node.type === 'JSXElement') {
+            var openingElement = node.openingElement;
+            if (openingElement && openingElement.name && openingElement.name.type === 'JSXIdentifier') {
+                var className_1 = getClassName(openingElement.attributes);
+                if (className_1) {
+                    detectedPaginations.forEach(function (detected, index) {
+                        var info = paginationInfos[index];
+                        if (!info) {
+                            return;
+                        }
+                        if (className_1 === detected.prevButtonClass) {
+                            convertToButton(node, info, 'prev');
+                        }
+                        else if (className_1 === detected.nextButtonClass) {
+                            convertToButton(node, info, 'next');
+                        }
+                    });
+                }
+            }
+        }
+        if (typeof node === 'object') {
+            Object.values(node).forEach(function (value) {
+                if (Array.isArray(value)) {
+                    value.forEach(function (item) { return modifyNode(item); });
+                }
+                else if (typeof value === 'object') {
+                    modifyNode(value);
+                }
+            });
+        }
+    };
+    modifyNode(blockStatement);
+}
+function modifySearchInputs(blockStatement, detectedPaginations, paginationInfos) {
+    var modifyNode = function (node) {
+        if (!node) {
+            return;
+        }
+        if (node.type === 'JSXElement') {
+            var openingElement = node.openingElement;
+            if (openingElement && openingElement.name && openingElement.name.type === 'JSXIdentifier') {
+                var className_2 = getClassName(openingElement.attributes);
+                if (className_2) {
+                    detectedPaginations.forEach(function (detected, index) {
+                        var info = paginationInfos[index];
+                        if (!info || !info.searchEnabled) {
+                            return;
+                        }
+                        if (className_2 === detected.searchInputClass) {
+                            addSearchInputHandlers(node, info);
+                        }
+                        else if (className_2 && className_2.includes('search-input')) {
+                            // Fallback: match any input with 'search-input' in class
+                            addSearchInputHandlers(node, info);
+                        }
+                    });
+                }
+            }
+        }
+        if (typeof node === 'object') {
+            Object.values(node).forEach(function (value) {
+                if (Array.isArray(value)) {
+                    value.forEach(function (item) { return modifyNode(item); });
+                }
+                else if (typeof value === 'object') {
+                    modifyNode(value);
+                }
+            });
+        }
+    };
+    modifyNode(blockStatement);
+}
+function addSearchInputHandlers(jsxElement, info) {
+    if (!info.searchQueryVar || !info.setSearchQueryVar) {
+        return;
+    }
+    var openingElement = jsxElement.openingElement;
+    removeAttribute(openingElement.attributes, 'onChange');
+    removeAttribute(openingElement.attributes, 'value');
+    var onChangeHandler = types.arrowFunctionExpression([types.identifier('e')], types.callExpression(types.identifier(info.setSearchQueryVar), [
+        types.memberExpression(types.memberExpression(types.identifier('e'), types.identifier('target')), types.identifier('value')),
+    ]));
+    openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('onChange'), types.jsxExpressionContainer(onChangeHandler)));
+    openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('value'), types.jsxExpressionContainer(types.identifier(info.searchQueryVar))));
+}
+function convertToButton(jsxElement, info, buttonType) {
+    var openingElement = jsxElement.openingElement;
+    if (openingElement.name.type === 'JSXIdentifier') {
+        openingElement.name.name = 'button';
+    }
+    if (jsxElement.closingElement && jsxElement.closingElement.name.type === 'JSXIdentifier') {
+        jsxElement.closingElement.name.name = 'button';
+    }
+    removeAttribute(openingElement.attributes, 'onClick');
+    removeAttribute(openingElement.attributes, 'disabled');
+    removeAttribute(openingElement.attributes, 'type');
+    var combinedStateVar = info.combinedStateVar;
+    var setCombinedStateVar = info.setCombinedStateVar;
+    var onClickHandler;
+    if (info.searchEnabled && combinedStateVar && setCombinedStateVar) {
+        // Use combined state: update only the page property
+        onClickHandler =
+            buttonType === 'prev'
+                ? types.arrowFunctionExpression([], types.callExpression(types.identifier(setCombinedStateVar), [
+                    types.arrowFunctionExpression([types.identifier('state')], types.objectExpression([
+                        types.spreadElement(types.identifier('state')),
+                        types.objectProperty(types.identifier('page'), types.callExpression(types.memberExpression(types.identifier('Math'), types.identifier('max')), [
+                            types.numericLiteral(1),
+                            types.binaryExpression('-', types.memberExpression(types.identifier('state'), types.identifier('page')), types.numericLiteral(1)),
+                        ])),
+                    ])),
+                ]))
+                : types.arrowFunctionExpression([], types.callExpression(types.identifier(setCombinedStateVar), [
+                    types.arrowFunctionExpression([types.identifier('state')], types.objectExpression([
+                        types.spreadElement(types.identifier('state')),
+                        types.objectProperty(types.identifier('page'), types.binaryExpression('+', types.memberExpression(types.identifier('state'), types.identifier('page')), types.numericLiteral(1))),
+                    ])),
+                ]));
+    }
+    else {
+        // Regular pagination (no search)
+        onClickHandler =
+            buttonType === 'prev'
+                ? types.arrowFunctionExpression([], types.callExpression(types.identifier(info.setPageStateVar), [
+                    types.arrowFunctionExpression([types.identifier('p')], types.callExpression(types.memberExpression(types.identifier('Math'), types.identifier('max')), [
+                        types.numericLiteral(1),
+                        types.binaryExpression('-', types.identifier('p'), types.numericLiteral(1)),
+                    ])),
+                ]))
+                : types.arrowFunctionExpression([], types.callExpression(types.identifier(info.setPageStateVar), [
+                    types.arrowFunctionExpression([types.identifier('p')], types.binaryExpression('+', types.identifier('p'), types.numericLiteral(1))),
+                ]));
+    }
+    openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('onClick'), types.jsxExpressionContainer(onClickHandler)));
+    openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('type'), types.stringLiteral('button')));
+    // Add disabled attribute with simple page number checks
+    var maxPagesStateVar = info.maxPagesStateVar;
+    var disabledExpr;
+    if (info.searchEnabled && combinedStateVar) {
+        disabledExpr =
+            buttonType === 'prev'
+                ? types.binaryExpression('<=', types.memberExpression(types.identifier(combinedStateVar), types.identifier('page')), types.numericLiteral(1))
+                : types.binaryExpression('>=', types.memberExpression(types.identifier(combinedStateVar), types.identifier('page')), types.identifier(maxPagesStateVar));
+    }
+    else {
+        disabledExpr =
+            buttonType === 'prev'
+                ? types.binaryExpression('<=', types.identifier(info.pageStateVar), types.numericLiteral(1))
+                : types.binaryExpression('>=', types.identifier(info.pageStateVar), types.identifier(maxPagesStateVar));
+    }
+    openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('disabled'), types.jsxExpressionContainer(disabledExpr)));
+}
+function getClassName(attributes) {
+    var classNameAttr = attributes.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'className'; });
+    if (classNameAttr && classNameAttr.value && classNameAttr.value.type === 'StringLiteral') {
+        return classNameAttr.value.value;
+    }
+    return null;
+}
+function removeAttribute(attrs, attributeName) {
+    var index = attrs.findIndex(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === attributeName; });
+    if (index !== -1) {
+        attrs.splice(index, 1);
+    }
+}
+function modifyGetStaticPropsForPagination(chunks, paginationInfos) {
+    var _a;
+    var getStaticPropsChunk = chunks.find(function (chunk) { return chunk.name === 'getStaticProps'; });
+    if (!getStaticPropsChunk || getStaticPropsChunk.type !== 'ast') {
+        return;
+    }
+    var exportDeclaration = getStaticPropsChunk.content;
+    if (!exportDeclaration || exportDeclaration.type !== 'ExportNamedDeclaration') {
+        return;
+    }
+    var functionDeclaration = exportDeclaration.declaration;
+    if (!functionDeclaration || functionDeclaration.type !== 'FunctionDeclaration') {
+        return;
+    }
+    // Find Promise.all and add NEW fetchData calls for each paginated DataProvider
+    var functionBody = functionDeclaration.body.body;
+    var tryBlock = functionBody.find(function (stmt) { return stmt.type === 'TryStatement'; });
+    if (!tryBlock) {
+        return;
+    }
+    var tryBody = tryBlock.block.body;
+    // Find the Promise.all statement
+    var promiseAllStmt = tryBody.find(function (stmt) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        return stmt.type === 'VariableDeclaration' &&
+            ((_c = (_b = (_a = stmt.declarations) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.init) === null || _c === void 0 ? void 0 : _c.type) === 'AwaitExpression' &&
+            ((_g = (_f = (_e = (_d = stmt.declarations) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.init) === null || _f === void 0 ? void 0 : _f.argument) === null || _g === void 0 ? void 0 : _g.type) === 'CallExpression' &&
+            ((_m = (_l = (_k = (_j = (_h = stmt.declarations) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.init) === null || _k === void 0 ? void 0 : _k.argument) === null || _l === void 0 ? void 0 : _l.callee) === null || _m === void 0 ? void 0 : _m.type) === 'MemberExpression' &&
+            ((_t = (_s = (_r = (_q = (_p = (_o = stmt.declarations) === null || _o === void 0 ? void 0 : _o[0]) === null || _p === void 0 ? void 0 : _p.init) === null || _q === void 0 ? void 0 : _q.argument) === null || _r === void 0 ? void 0 : _r.callee) === null || _s === void 0 ? void 0 : _s.property) === null || _t === void 0 ? void 0 : _t.name) === 'all';
+    });
+    if (!promiseAllStmt) {
+        return;
+    }
+    var awaitExpr = promiseAllStmt.declarations[0].init;
+    var promiseAllCall = awaitExpr.argument;
+    var promiseArray = promiseAllCall.arguments[0];
+    var destructuringPattern = promiseAllStmt.declarations[0].id;
+    // Map import names to data source identifiers from existing fetchData calls
+    // Also track which indices to remove (non-paginated calls that will be replaced)
+    var importToDataSource = new Map();
+    var indicesToRemove = [];
+    promiseArray.elements.forEach(function (element, index) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        if (element && element.type === 'CallExpression') {
+            var fetchCallExpr = element;
+            // If wrapped in .catch(), unwrap it
+            if (((_a = element.callee) === null || _a === void 0 ? void 0 : _a.type) === 'MemberExpression' &&
+                ((_c = (_b = element.callee) === null || _b === void 0 ? void 0 : _b.property) === null || _c === void 0 ? void 0 : _c.name) === 'catch' &&
+                ((_e = (_d = element.callee) === null || _d === void 0 ? void 0 : _d.object) === null || _e === void 0 ? void 0 : _e.type) === 'CallExpression') {
+                fetchCallExpr = element.callee.object;
+            }
+            // Now find the .fetchData() call
+            if (((_f = fetchCallExpr.callee) === null || _f === void 0 ? void 0 : _f.type) === 'MemberExpression' &&
+                ((_h = (_g = fetchCallExpr.callee) === null || _g === void 0 ? void 0 : _g.property) === null || _h === void 0 ? void 0 : _h.name) === 'fetchData' &&
+                ((_k = (_j = fetchCallExpr.callee) === null || _j === void 0 ? void 0 : _j.object) === null || _k === void 0 ? void 0 : _k.type) === 'Identifier') {
+                var importName = fetchCallExpr.callee.object.name;
+                var dataSourceVar_1 = destructuringPattern.elements[index].name;
+                // Check if this fetchData call has page/perPage params
+                var params = fetchCallExpr.arguments[0];
+                var hasPageParam = params &&
+                    params.type === 'ObjectExpression' &&
+                    params.properties.some(function (prop) {
+                        return prop.type === 'ObjectProperty' &&
+                            (prop.key.name === 'page' || prop.key.name === 'perPage');
+                    });
+                // If this is a data source that will be paginated but this call has NO pagination params,
+                // mark it for removal
+                if (!hasPageParam &&
+                    paginationInfos.some(function (info) { return info.dataSourceIdentifier === dataSourceVar_1; })) {
+                    indicesToRemove.push(index);
+                }
+                importToDataSource.set(importName, dataSourceVar_1);
+            }
+        }
+    });
+    // Remove non-paginated fetchData calls in reverse order to preserve indices
+    indicesToRemove.reverse().forEach(function (index) {
+        var _a, _b;
+        // Get the prop name BEFORE removing it
+        var propToRemove = (_a = destructuringPattern.elements[index]) === null || _a === void 0 ? void 0 : _a.name;
+        promiseArray.elements.splice(index, 1);
+        destructuringPattern.elements.splice(index, 1);
+        // Also remove from props in return statement
+        if (propToRemove) {
+            var foundReturnStmt = tryBody.find(function (stmt) { return stmt.type === 'ReturnStatement'; });
+            if (foundReturnStmt && ((_b = foundReturnStmt.argument) === null || _b === void 0 ? void 0 : _b.type) === 'ObjectExpression') {
+                var propsProperty = foundReturnStmt.argument.properties.find(function (prop) {
+                    return prop.type === 'ObjectProperty' && prop.key.name === 'props';
+                });
+                if (propsProperty && propsProperty.value.type === 'ObjectExpression') {
+                    var propsObject = propsProperty.value;
+                    var propIndex = propsObject.properties.findIndex(function (prop) {
+                        return prop.type === 'ObjectProperty' && prop.key.name === propToRemove;
+                    });
+                    if (propIndex !== -1) {
+                        propsObject.properties.splice(propIndex, 1);
+                    }
+                }
+            }
+        }
+    });
+    // Add NEW fetchData calls for each paginated DataProvider
+    paginationInfos.forEach(function (info, index) {
+        var _a, _b;
+        // Try exact match first, then case-insensitive match
+        var importName = (_a = Array.from(importToDataSource.entries()).find(function (_a) {
+            var _ = _a[0], dataSourceVar = _a[1];
+            return dataSourceVar === info.dataSourceIdentifier;
+        })) === null || _a === void 0 ? void 0 : _a[0];
+        if (!importName) {
+            // Try case-insensitive match
+            var normalizedIdentifier_1 = info.dataSourceIdentifier.toLowerCase().replace(/[_-]/g, '');
+            importName = (_b = Array.from(importToDataSource.entries()).find(function (_a) {
+                var _ = _a[0], dataSourceVar = _a[1];
+                return dataSourceVar.toLowerCase().replace(/[_-]/g, '') === normalizedIdentifier_1;
+            })) === null || _b === void 0 ? void 0 : _b[0];
+        }
+        if (importName) {
+            var paginatedVarName = "".concat(info.dataSourceIdentifier, "_pg_").concat(index);
+            var fetchParams = [
+                types.objectProperty(types.identifier('page'), types.numericLiteral(1)),
+                types.objectProperty(types.identifier('perPage'), types.numericLiteral(info.perPage)),
+            ];
+            // Add queryColumns if they exist
+            if (info.queryColumns && info.queryColumns.length > 0) {
+                fetchParams.push(types.objectProperty(types.identifier('queryColumns'), types.arrayExpression(info.queryColumns.map(function (col) { return types.stringLiteral(col); }))));
+            }
+            // Create new fetchData call with pagination params
+            var newFetchDataCall = types.callExpression(types.memberExpression(types.callExpression(types.memberExpression(types.identifier(importName), types.identifier('fetchData')), [types.objectExpression(fetchParams)]), types.identifier('catch')), [
+                types.arrowFunctionExpression([types.identifier('error')], types.blockStatement([
+                    types.expressionStatement(types.callExpression(types.memberExpression(types.identifier('console'), types.identifier('error')), [
+                        types.stringLiteral("Error fetching ".concat(paginatedVarName, ":")),
+                        types.identifier('error'),
+                    ])),
+                    types.returnStatement(types.arrayExpression([])),
+                ])),
+            ]);
+            promiseArray.elements.push(newFetchDataCall);
+            destructuringPattern.elements.push(types.identifier(paginatedVarName));
+        }
+    });
+    // Add fetchCount calls for paginated data sources (deduplicated by data source)
+    // Deduplicate by data source identifier
+    var uniqueDataSources = new Set(paginationInfos.map(function (info) { return info.dataSourceIdentifier; }));
+    var addedCountFetches = new Set();
+    uniqueDataSources.forEach(function (dataSourceId) {
+        var _a, _b;
+        var importName = (_a = Array.from(importToDataSource.entries()).find(function (_a) {
+            var _ = _a[0], dataSourceVar = _a[1];
+            return dataSourceVar === dataSourceId;
+        })) === null || _a === void 0 ? void 0 : _a[0];
+        if (!importName) {
+            // Try case-insensitive match
+            var normalizedIdentifier_2 = dataSourceId.toLowerCase().replace(/[_-]/g, '');
+            importName = (_b = Array.from(importToDataSource.entries()).find(function (_a) {
+                var _ = _a[0], dataSourceVar = _a[1];
+                return dataSourceVar.toLowerCase().replace(/[_-]/g, '') === normalizedIdentifier_2;
+            })) === null || _b === void 0 ? void 0 : _b[0];
+        }
+        if (importName && !addedCountFetches.has(dataSourceId)) {
+            var fetchCountCall = types.callExpression(types.memberExpression(types.identifier(importName), types.identifier('fetchCount')), []);
+            promiseArray.elements.push(fetchCountCall);
+            destructuringPattern.elements.push(types.identifier("".concat(dataSourceId, "_count")));
+            addedCountFetches.add(dataSourceId);
+        }
+    });
+    // Calculate and add maxPages before return
+    var returnStmt = tryBody.find(function (stmt) { return stmt.type === 'ReturnStatement'; });
+    if (returnStmt && ((_a = returnStmt.argument) === null || _a === void 0 ? void 0 : _a.type) === 'ObjectExpression') {
+        var propsProperty = returnStmt.argument.properties.find(function (prop) {
+            return prop.type === 'ObjectProperty' && prop.key.name === 'props';
+        });
+        if (propsProperty && propsProperty.value.type === 'ObjectExpression') {
+            var propsObject_1 = propsProperty.value;
+            var returnIndex_1 = tryBody.indexOf(returnStmt);
+            paginationInfos.forEach(function (info, index) {
+                var paginatedVarName = "".concat(info.dataSourceIdentifier, "_pg_").concat(index);
+                var countVarName = "".concat(info.dataSourceIdentifier, "_count");
+                var maxPagesVarName = "".concat(info.dataSourceIdentifier, "_pg_").concat(index, "_maxPages");
+                var maxPagesCalc = types.variableDeclaration('const', [
+                    types.variableDeclarator(types.identifier(maxPagesVarName), types.callExpression(types.memberExpression(types.identifier('Math'), types.identifier('ceil')), [
+                        types.binaryExpression('/', types.logicalExpression('||', types.identifier(countVarName), types.numericLiteral(0)), types.numericLiteral(info.perPage)),
+                    ])),
+                ]);
+                tryBody.splice(returnIndex_1, 0, maxPagesCalc);
+                // Add both the paginated data and maxPages to props
+                propsObject_1.properties.push(types.objectProperty(types.identifier(paginatedVarName), types.identifier(paginatedVarName)));
+                propsObject_1.properties.push(types.objectProperty(types.identifier(maxPagesVarName), types.identifier(maxPagesVarName)));
+            });
+        }
+    }
+}
+function createAPIRoutesForPaginatedDataSources(uidlNode, dataSources, componentChunk, extractedResources, paginationInfos, isComponent) {
+    var paginatedDataSourceIds = new Set(paginationInfos.map(function (info) { return info.dataSourceIdentifier; }));
+    var traverseForDataSources = function (node) {
+        var _a;
+        if (!node) {
+            return;
+        }
+        if (node.type === 'data-source-list' || node.type === 'data-source-item') {
+            var renderProp = node.content.renderPropIdentifier;
+            if (renderProp && paginatedDataSourceIds.has(renderProp)) {
+                (0, utils_1.extractDataSourceIntoNextAPIFolder)(node, dataSources, componentChunk, extractedResources);
+                // For components, also create count API route
+                if (isComponent) {
+                    var resourceDef = node.content.resourceDefinition;
+                    if (resourceDef) {
+                        var dataSourceId = resourceDef.dataSourceId;
+                        var tableName = resourceDef.tableName;
+                        var dataSourceType = resourceDef.dataSourceType;
+                        var fileName = "".concat(dataSourceType, "-").concat(tableName, "-").concat(dataSourceId.substring(0, 8));
+                        var countFileName = "".concat(fileName, "-count");
+                        // Create count API route that exports getCount handler
+                        extractedResources["api/".concat(countFileName)] = {
+                            fileName: countFileName,
+                            fileType: teleport_types_1.FileType.JS,
+                            path: ['pages', 'api'],
+                            content: "import dataSource from '../../utils/data-sources/".concat(fileName, "'\n\nexport default dataSource.getCount\n"),
+                        };
+                    }
+                }
+            }
+        }
+        if ((_a = node.content) === null || _a === void 0 ? void 0 : _a.children) {
+            node.content.children.forEach(function (child) { return traverseForDataSources(child); });
+        }
+    };
+    traverseForDataSources(uidlNode);
+}
+function createAPIRoutesForSearchOnlyDataSources(uidlNode, dataSources, componentChunk, extractedResources, searchOnlyDataSources) {
+    var searchOnlyDataSourceIds = new Set(searchOnlyDataSources.map(function (info) { return info.dataSourceIdentifier; }));
+    var traverseForDataSources = function (node) {
+        var _a;
+        if (!node) {
+            return;
+        }
+        if (node.type === 'data-source-list' || node.type === 'data-source-item') {
+            var renderProp = node.content.renderPropIdentifier;
+            if (renderProp && searchOnlyDataSourceIds.has(renderProp)) {
+                (0, utils_1.extractDataSourceIntoNextAPIFolder)(node, dataSources, componentChunk, extractedResources);
+            }
+        }
+        if ((_a = node.content) === null || _a === void 0 ? void 0 : _a.children) {
+            node.content.children.forEach(function (child) { return traverseForDataSources(child); });
+        }
+    };
+    traverseForDataSources(uidlNode);
+}
+exports.default = (0, exports.createNextArrayMapperPaginationPlugin)();
+//# sourceMappingURL=pagination-plugin.js.map