@teleporthq/teleport-plugin-next-data-source 0.43.57 → 0.43.60

package/src/array-mapper-registry.ts

@@ -1,416 +0,0 @@
-/**
- * ArrayMapperRegistry - Centralized registry for managing array mappers,
- * their associated states, search inputs, and pagination buttons.
- *
- * This ensures consistent index usage across:
- * - Component state declarations
- * - DataProvider params
- * - getStaticProps fetch calls and prop names
- * - Search input bindings
- * - Pagination button bindings
- */
-
-export type MapperType = 'paginated' | 'pagination-only' | 'search-only' | 'plain'
-
-export interface ArrayMapperRegistryEntry {
-  registryIndex: number
-  type: MapperType
-  dataSourceIdentifier: string
-  arrayMapperRenderProp: string
-  uidlGlobalIndex: number
-
-  paginated: boolean
-  searchEnabled: boolean
-  perPage: number
-  searchDebounce: number
-  searchDefaultValue?: string
-  queryColumns: string[]
-
-  stateVarPrefix: string
-  pageStateVar?: string
-  setPageStateVar?: string
-  maxPagesStateVar?: string
-  setMaxPagesStateVar?: string
-  combinedStateVar?: string
-  setCombinedStateVar?: string
-  searchQueryVar?: string
-  setSearchQueryVar?: string
-  debouncedSearchQueryVar?: string
-  setDebouncedSearchQueryVar?: string
-  skipDebounceRefVar?: string
-
-  getStaticPropsDataVar: string
-  getStaticPropsMaxPagesVar: string
-  getStaticPropsPropName: string
-  getStaticPropsMaxPagesPropName: string
-
-  searchInputClass?: string
-  paginationNodeClass?: string
-  prevButtonClass?: string
-  nextButtonClass?: string
-
-  dataProviderJSX?: any
-  searchInputJSX?: any
-}
-
-export class ArrayMapperRegistry {
-  private entries: ArrayMapperRegistryEntry[] = []
-  private paginatedCount = 0
-  private paginationOnlyCount = 0
-  private searchOnlyCount = 0
-  private plainCount = 0
-
-  registerFromUIDL(config: {
-    dataSourceIdentifier: string
-    arrayMapperRenderProp: string
-    uidlGlobalIndex: number
-    paginated: boolean
-    searchEnabled: boolean
-    perPage?: number
-    searchDebounce?: number
-    searchDefaultValue?: string
-    queryColumns?: string[]
-  }): ArrayMapperRegistryEntry {
-    const type = this.determineType(config.paginated, config.searchEnabled)
-    const typeIndex = this.getTypeIndex(type)
-    const registryIndex = this.entries.length
-
-    const stateVarPrefix = this.generateStateVarPrefix(type, typeIndex)
-
-    const entry: ArrayMapperRegistryEntry = {
-      registryIndex,
-      type,
-      dataSourceIdentifier: config.dataSourceIdentifier,
-      arrayMapperRenderProp: config.arrayMapperRenderProp,
-      uidlGlobalIndex: config.uidlGlobalIndex,
-
-      paginated: config.paginated,
-      searchEnabled: config.searchEnabled,
-      perPage: config.perPage || 10,
-      searchDebounce: config.searchDebounce || 300,
-      searchDefaultValue: config.searchDefaultValue,
-      queryColumns: config.queryColumns || [],
-
-      stateVarPrefix,
-      ...this.generateStateVarNames(stateVarPrefix, config.paginated, config.searchEnabled),
-      ...this.generateGetStaticPropsVarNames(config.dataSourceIdentifier, type, typeIndex),
-    }
-
-    this.entries.push(entry)
-    this.incrementTypeCount(type)
-
-    return entry
-  }
-
-  getEntry(registryIndex: number): ArrayMapperRegistryEntry | undefined {
-    return this.entries[registryIndex]
-  }
-
-  getEntryByUIDLIndex(uidlGlobalIndex: number): ArrayMapperRegistryEntry | undefined {
-    return this.entries.find((e) => e.uidlGlobalIndex === uidlGlobalIndex)
-  }
-
-  getEntriesByType(type: MapperType): ArrayMapperRegistryEntry[] {
-    return this.entries.filter((e) => e.type === type)
-  }
-
-  getAllEntries(): ArrayMapperRegistryEntry[] {
-    return [...this.entries]
-  }
-
-  getPaginatedEntries(): ArrayMapperRegistryEntry[] {
-    return this.getEntriesByType('paginated')
-  }
-
-  getPaginationOnlyEntries(): ArrayMapperRegistryEntry[] {
-    return this.getEntriesByType('pagination-only')
-  }
-
-  getSearchOnlyEntries(): ArrayMapperRegistryEntry[] {
-    return this.getEntriesByType('search-only')
-  }
-
-  getPlainEntries(): ArrayMapperRegistryEntry[] {
-    return this.getEntriesByType('plain')
-  }
-
-  updateJSXReferences(
-    registryIndex: number,
-    updates: Partial<
-      Pick<
-        ArrayMapperRegistryEntry,
-        | 'dataProviderJSX'
-        | 'searchInputJSX'
-        | 'searchInputClass'
-        | 'paginationNodeClass'
-        | 'prevButtonClass'
-        | 'nextButtonClass'
-      >
-    >
-  ): void {
-    const entry = this.entries[registryIndex]
-    if (entry) {
-      Object.assign(entry, updates)
-    }
-  }
-
-  getStateInitializationMaxPagesPropName(entry: ArrayMapperRegistryEntry): string {
-    return entry.getStaticPropsMaxPagesPropName
-  }
-
-  toDebugSummary(): string {
-    return JSON.stringify(
-      this.entries.map((e) => ({
-        registryIndex: e.registryIndex,
-        type: e.type,
-        dataSource: e.dataSourceIdentifier,
-        renderProp: e.arrayMapperRenderProp,
-        uidlIndex: e.uidlGlobalIndex,
-        statePrefix: e.stateVarPrefix,
-        getStaticPropsProp: e.getStaticPropsPropName,
-      })),
-      null,
-      2
-    )
-  }
-
-  private determineType(paginated: boolean, searchEnabled: boolean): MapperType {
-    if (paginated && searchEnabled) {
-      return 'paginated'
-    }
-
-    if (paginated && !searchEnabled) {
-      return 'pagination-only'
-    }
-
-    if (!paginated && searchEnabled) {
-      return 'search-only'
-    }
-
-    return 'plain'
-  }
-
-  private getTypeIndex(type: MapperType): number {
-    switch (type) {
-      case 'paginated':
-        return this.paginatedCount
-      case 'pagination-only':
-        return this.paginationOnlyCount
-      case 'search-only':
-        return this.searchOnlyCount
-      case 'plain':
-        return this.plainCount
-      default:
-        return 0
-    }
-  }
-
-  private incrementTypeCount(type: MapperType): void {
-    switch (type) {
-      case 'paginated':
-        this.paginatedCount++
-        break
-      case 'pagination-only':
-        this.paginationOnlyCount++
-        break
-      case 'search-only':
-        this.searchOnlyCount++
-        break
-      case 'plain':
-        this.plainCount++
-        break
-      default:
-        break
-    }
-  }
-
-  private generateStateVarPrefix(type: MapperType, typeIndex: number): string {
-    switch (type) {
-      case 'paginated':
-        return `pg_${typeIndex}`
-      case 'pagination-only':
-        return `paginationOnly_${typeIndex}`
-      case 'search-only':
-        return `searchOnly_${typeIndex}`
-      case 'plain':
-        return `plain_${typeIndex}`
-      default:
-        return ''
-    }
-  }
-
-  private generateStateVarNames(
-    prefix: string,
-    paginated: boolean,
-    searchEnabled: boolean
-  ): Partial<ArrayMapperRegistryEntry> {
-    const result: Partial<ArrayMapperRegistryEntry> = {}
-
-    if (paginated) {
-      if (searchEnabled) {
-        result.combinedStateVar = `paginationState_${prefix}`
-        result.setCombinedStateVar = `setPaginationState_${prefix}`
-        result.pageStateVar = `paginationState_${prefix}.page`
-        result.setPageStateVar = `setPaginationState_${prefix}`
-      } else {
-        result.pageStateVar = `${prefix}_page`
-        result.setPageStateVar = `set${this.capitalize(prefix)}_page`
-      }
-      result.maxPagesStateVar = `pagination_${prefix}_maxPages`
-      result.setMaxPagesStateVar = `setPagination_${prefix}_maxPages`
-    } else {
-      result.pageStateVar = ''
-      result.setPageStateVar = ''
-      result.maxPagesStateVar = ''
-      result.setMaxPagesStateVar = ''
-    }
-
-    if (searchEnabled) {
-      result.searchQueryVar = `search_${prefix}_query`
-      result.setSearchQueryVar = `setSearch_${prefix}_query`
-      result.debouncedSearchQueryVar = `debouncedSearch_${prefix}_query`
-      result.setDebouncedSearchQueryVar = `setDebouncedSearch_${prefix}_query`
-      result.skipDebounceRefVar = `skipDebounceOnMount_${prefix}`
-    }
-
-    return result
-  }
-
-  private generateGetStaticPropsVarNames(
-    dataSourceIdentifier: string,
-    type: MapperType,
-    typeIndex: number
-  ): Pick<
-    ArrayMapperRegistryEntry,
-    | 'getStaticPropsDataVar'
-    | 'getStaticPropsMaxPagesVar'
-    | 'getStaticPropsPropName'
-    | 'getStaticPropsMaxPagesPropName'
-  > {
-    let suffix: string
-    switch (type) {
-      case 'paginated':
-        suffix = `pg_${typeIndex}`
-        break
-      case 'pagination-only':
-        suffix = `paginationOnly_${typeIndex}`
-        break
-      case 'search-only':
-        suffix = `searchOnly_${typeIndex}`
-        break
-      case 'plain':
-        suffix = `plain_${typeIndex}`
-        break
-      default:
-        suffix = `plain_${typeIndex}`
-        break
-    }
-
-    const dataVar = `${dataSourceIdentifier}_${suffix}`
-    const maxPagesVar = `${dataSourceIdentifier}_${suffix}_maxPages`
-
-    return {
-      getStaticPropsDataVar: dataVar,
-      getStaticPropsMaxPagesVar: maxPagesVar,
-      getStaticPropsPropName: dataVar,
-      getStaticPropsMaxPagesPropName: maxPagesVar,
-    }
-  }
-
-  private capitalize(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1)
-  }
-}
-
-export function createRegistryFromUIDL(uidlNode: any, allResources: any): ArrayMapperRegistry {
-  const registry = new ArrayMapperRegistry()
-
-  const visitedRepeaterKeys = new Set<string>()
-  let uidlGlobalIndex = 0
-
-  const findQueryColumns = (
-    resourceId: string,
-    nodeResource: any,
-    registryResources: any
-  ): string[] | undefined => {
-    if (nodeResource?.params?.queryColumns) {
-      const val = nodeResource.params.queryColumns
-      if (val.type === 'static' && Array.isArray(val.content)) {
-        return val.content
-      }
-    }
-    if (registryResources?.items?.[resourceId]?.params?.queryColumns) {
-      const val = registryResources.items[resourceId].params.queryColumns
-      if (val.type === 'static' && Array.isArray(val.content)) {
-        return val.content
-      }
-    }
-    return undefined
-  }
-
-  const traverse = (node: any, currentDataSourceId?: string): void => {
-    if (!node || typeof node !== 'object') {
-      return
-    }
-
-    if (node.type === 'data-source-list' && node.content?.renderPropIdentifier) {
-      currentDataSourceId = node.content.renderPropIdentifier
-    }
-
-    if (node.type === 'cms-list-repeater' && node.content?.renderPropIdentifier) {
-      const c = node.content
-      const repeaterKey = `${c.renderPropIdentifier}|${c.paginated}|${c.searchEnabled}|${
-        c.perPage || 'default'
-      }|${c.source || ''}`
-
-      if (visitedRepeaterKeys.has(repeaterKey)) {
-        return
-      }
-      visitedRepeaterKeys.add(repeaterKey)
-
-      const resourceId = c.resource?.id
-      let queryColumns: string[] | undefined
-      if (resourceId) {
-        queryColumns = findQueryColumns(resourceId, c.resource, allResources)
-      }
-
-      const rawDefault = c.searchDefaultValue
-      const searchDefaultValue =
-        rawDefault &&
-        rawDefault.type === 'static' &&
-        typeof rawDefault.content === 'string' &&
-        rawDefault.content.length > 0
-          ? rawDefault.content
-          : undefined
-
-      registry.registerFromUIDL({
-        dataSourceIdentifier: currentDataSourceId || 'unknown',
-        arrayMapperRenderProp: c.renderPropIdentifier,
-        uidlGlobalIndex: uidlGlobalIndex++,
-        paginated: !!c.paginated,
-        searchEnabled: !!c.searchEnabled,
-        perPage: c.perPage,
-        searchDebounce: c.searchDebounce,
-        searchDefaultValue,
-        queryColumns,
-      })
-    }
-
-    if (node.content?.children && Array.isArray(node.content.children)) {
-      node.content.children.forEach((child: any) => traverse(child, currentDataSourceId))
-    }
-    if (node.content?.node) {
-      traverse(node.content.node, currentDataSourceId)
-    }
-    if (node.content?.nodes) {
-      Object.values(node.content.nodes).forEach((n: any) => traverse(n, currentDataSourceId))
-    }
-    if (Array.isArray(node.children)) {
-      node.children.forEach((child: any) => traverse(child, currentDataSourceId))
-    }
-  }
-
-  traverse(uidlNode)
-
-  return registry
-}

package/src/pagination-with-count.ts

@@ -1,89 +0,0 @@
-import * as types from '@babel/types'
-import { ArrayMapperPaginationInfo } from './array-mapper-pagination'
-
-export function generateTotalPagesState(
-  info: ArrayMapperPaginationInfo
-): types.VariableDeclaration {
-  const totalStateVar = `pagination_${info.paginationNodeId}_total`
-  const setTotalStateVar = `setPagination_${info.paginationNodeId}_total`
-
-  return types.variableDeclaration('const', [
-    types.variableDeclarator(
-      types.arrayPattern([types.identifier(totalStateVar), types.identifier(setTotalStateVar)]),
-      types.callExpression(types.identifier('useState'), [types.numericLiteral(0)])
-    ),
-  ])
-}
-
-export function generateTotalPagesCalculation(
-  info: ArrayMapperPaginationInfo
-): types.VariableDeclaration {
-  const totalStateVar = `pagination_${info.paginationNodeId}_total`
-  const totalPagesVar = `pagination_${info.paginationNodeId}_totalPages`
-
-  return types.variableDeclaration('const', [
-    types.variableDeclarator(
-      types.identifier(totalPagesVar),
-      types.callExpression(
-        types.memberExpression(types.identifier('Math'), types.identifier('ceil')),
-        [
-          types.binaryExpression(
-            '/',
-            types.identifier(totalStateVar),
-            types.numericLiteral(info.perPage)
-          ),
-        ]
-      )
-    ),
-  ])
-}
-
-export function wrapFetchDataWithTotalExtraction(
-  fetchDataExpr: types.ArrowFunctionExpression,
-  setTotalStateVar: string
-): types.ArrowFunctionExpression {
-  // Wrap the existing fetchData to extract total from response
-  const wrappedBody = types.blockStatement([
-    types.returnStatement(
-      types.callExpression(
-        types.memberExpression(
-          types.callExpression(fetchDataExpr.body as types.Expression, []),
-          types.identifier('then')
-        ),
-        [
-          types.arrowFunctionExpression(
-            [types.identifier('response')],
-            types.blockStatement([
-              types.ifStatement(
-                types.logicalExpression(
-                  '&&',
-                  types.identifier('response'),
-                  types.memberExpression(types.identifier('response'), types.identifier('total'))
-                ),
-                types.blockStatement([
-                  types.expressionStatement(
-                    types.callExpression(types.identifier(setTotalStateVar), [
-                      types.memberExpression(
-                        types.identifier('response'),
-                        types.identifier('total')
-                      ),
-                    ])
-                  ),
-                ])
-              ),
-              types.returnStatement(
-                types.conditionalExpression(
-                  types.memberExpression(types.identifier('response'), types.identifier('data')),
-                  types.memberExpression(types.identifier('response'), types.identifier('data')),
-                  types.identifier('response')
-                )
-              ),
-            ])
-          ),
-        ]
-      )
-    ),
-  ])
-
-  return types.arrowFunctionExpression(fetchDataExpr.params, wrappedBody)
-}