@patternfly/patternfly-doc-core 1.15.3 → 1.15.5

package/jest.config.ts

@@ -13,9 +13,11 @@ const config: Config = {
     '^.+\\.m?jsx?$': 'babel-jest',
   },
   testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.[jt]sx?$',
+  testPathIgnorePatterns: ['/node_modules/', '/__tests__/helpers/'],
   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
   moduleNameMapper: {
     '\\.(css|less)$': '<rootDir>/src/__mocks__/styleMock.ts',
+    '^astro:content$': '<rootDir>/src/__mocks__/astro-content.ts',
     '(.+)\\.js': '$1',
   },
   setupFilesAfterEnv: ['<rootDir>/test.setup.ts'],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@patternfly/patternfly-doc-core",
   "type": "module",
-  "version": "1.15.3",
+  "version": "1.15.5",
   "description": "PatternFly Core Documentation",
   "publishConfig": {
     "access": "public"
@@ -11,20 +11,22 @@
     "start": "npm run dev",
     "start:cli": "npm run build:cli && node ./dist/cli/cli.js start",
     "start:astro": "astro dev",
-    "build": "npm run build:cli && node ./dist/cli/cli.js build",
+    "build": "npm run build:cli && node --max-old-space-size=4096 ./dist/cli/cli.js build",
     "build:astro": "astro check && astro build",
     "build:cli": "tsc --build ./cli/tsconfig.json",
     "build:cli:watch": "tsc --build --watch ./cli/tsconfig.json",
     "build:props": "npm run build:cli && node ./dist/cli/cli.js generate-props",
-    "preview": "astro build && wrangler pages dev",
+    "preview": "wrangler pages dev",
     "astro": "astro",
-    "deploy": "npm run build && wrangler pages deploy",
+    "deploy": "npm run build:cli && node ./dist/cli/cli.js deploy",
+    "versions:upload": "wrangler versions upload",
     "prettier": "prettier --write ./src",
     "lint": "eslint . --cache --cache-strategy content",
     "test": "jest",
     "test:watch": "jest --watch",
     "semantic-release": "semantic-release",
-    "cf-typegen": "wrangler types"
+    "cf-typegen": "wrangler types",
+    "clean": "rm -rf dist .astro .wrangler"
   },
   "main": "dist/cli/cli.js",
   "bin": "./dist/cli/cli.js",
@@ -63,7 +65,7 @@
     "@patternfly/quickstarts": "^6.0.0",
     "@types/react": "^18.3.23",
     "@types/react-dom": "^18.3.7",
-    "astro": "5.15.9",
+    "astro": "^5.15.9",
     "change-case": "5.4.4",
     "commander": "^13.1.0",
     "glob": "^11.0.3",

package/public/_routes.json

@@ -0,0 +1,22 @@
+{
+  "version": 1,
+  "include": [
+    "/*"
+  ],
+  "exclude": [
+    "/",
+    "/_astro/*",
+    "/.assetsignore",
+    "/PF-HorizontalLogo-Color.svg",
+    "/PF-HorizontalLogo-Reverse.svg",
+    "/avatarImg.svg",
+    "/avatarImgDark.svg",
+    "/favicon.svg",
+    "/content/*",
+    "/components/*",
+    "/layouts/*",
+    "/patterns/*",
+    "/utility-classes/*",
+    "/extensions/*"
+  ]
+}

package/src/__mocks__/astro-content.ts

@@ -0,0 +1,6 @@
+// Mock for astro:content module
+// This is a virtual module in Astro, so we need to provide a mock for Jest
+
+export const getCollection = jest.fn();
+export const getEntry = jest.fn();
+export const getEntries = jest.fn();

package/src/content.ts

@@ -1 +1 @@
-export const content = [{"base":"/home/runner/work/patternfly-doc-core/patternfly-doc-core/node_modules/@patternfly/react-core","packageName":"@patternfly/react-core","pattern":"**/components/**/*.md","name":"react-component-docs"},{"base":"/home/runner/work/patternfly-doc-core/patternfly-doc-core/node_modules/@patternfly/patternfly","packageName":"@patternfly/patternfly","pattern":"*/**/*.md","name":"core-docs"},{"base":"/home/runner/work/patternfly-doc-core/patternfly-doc-core/node_modules/@patternfly/quickstarts","packageName":"@patternfly/quickstarts","pattern":"*/patternfly-docs/**/*.md","name":"quickstarts-docs"}]
+export const content = [{"base":"/home/runner/work/patternfly-doc-core/patternfly-doc-core/node_modules/@patternfly/react-core","packageName":"@patternfly/react-core","pattern":"**/components/**/*.md","name":"react-component-docs","version":"v6"},{"base":"/home/runner/work/patternfly-doc-core/patternfly-doc-core/node_modules/@patternfly/patternfly","packageName":"@patternfly/patternfly","pattern":"*/**/*.md","name":"core-docs","version":"v6"},{"base":"/home/runner/work/patternfly-doc-core/patternfly-doc-core/node_modules/@patternfly/quickstarts","packageName":"@patternfly/quickstarts","pattern":"*/patternfly-docs/**/*.md","name":"quickstarts-docs","version":"v6"}]

package/src/pages/api/[version]/[section]/[page]/[tab].ts

@@ -0,0 +1,153 @@
+/* eslint-disable no-console */
+import type { APIRoute, GetStaticPaths } from 'astro'
+import type { CollectionEntry, CollectionKey } from 'astro:content'
+import { getCollection } from 'astro:content'
+import { content } from '../../../../../content'
+import {
+  kebabCase,
+  addDemosOrDeprecated,
+  getDefaultTabForApi,
+} from '../../../../../utils'
+import { generateAndWriteApiIndex } from '../../../../../utils/apiIndex/generate'
+import { getApiIndex } from '../../../../../utils/apiIndex/get'
+import {
+  createJsonResponse,
+  createTextResponse,
+  createIndexKey,
+} from '../../../../../utils/apiHelpers'
+
+export const prerender = true
+
+type ContentEntry = CollectionEntry<
+  'core-docs' | 'quickstarts-docs' | 'react-component-docs'
+>
+
+export const getStaticPaths: GetStaticPaths = async () => {
+  // Generate index file for server-side routes to use
+  // This runs once during build when getCollection() is available
+  const index = await generateAndWriteApiIndex()
+
+  const paths: {
+    params: { version: string; section: string; page: string; tab: string }
+  }[] = []
+
+  // Build paths from index structure
+  for (const version of index.versions) {
+    for (const section of index.sections[version] || []) {
+      const sectionKey = createIndexKey(version, section)
+      for (const page of index.pages[sectionKey] || []) {
+        const pageKey = createIndexKey(version, section, page)
+        for (const tab of index.tabs[pageKey] || []) {
+          paths.push({ params: { version, section, page, tab } })
+        }
+      }
+    }
+  }
+
+  // This shouldn't happen since we have a fallback tab value, but if it somehow does we need to alert the user
+  paths.forEach((path) => {
+    if (!path.params.tab) {
+      console.warn(`[API Warning] Tab not found for path: ${path.params.version}/${path.params.section}/${path.params.page}`)
+    }
+  })
+
+  // Again, this shouldn't happen since we have a fallback tab value, but if it somehow does and we don't filter out tabless paths it will crash the build
+  return paths.filter((path) => !!path.params.tab)
+}
+
+export const GET: APIRoute = async ({ params }) => {
+  const { version, section, page, tab } = params
+
+  if (!version || !section || !page || !tab) {
+    return createJsonResponse(
+      { error: 'Version, section, page, and tab parameters are required' },
+      400,
+    )
+  }
+
+  // Validate using index first (fast path for 404s)
+  const index = await getApiIndex()
+
+  // Check if version exists
+  if (!index.versions.includes(version)) {
+    return createJsonResponse({ error: `Version '${version}' not found` }, 404)
+  }
+
+  // Check if section exists for this version
+  const sectionKey = createIndexKey(version, section)
+  if (!index.sections[version]?.includes(section)) {
+    return createJsonResponse(
+      { error: `Section '${section}' not found for version '${version}'` },
+      404,
+    )
+  }
+
+  // Check if page exists for this section
+  const pageKey = createIndexKey(version, section, page)
+  if (!index.pages[sectionKey]?.includes(page)) {
+    return createJsonResponse(
+      {
+        error: `Page '${page}' not found in section '${section}' for version '${version}'`,
+      },
+      404,
+    )
+  }
+
+  // Check if tab exists for this page
+  if (!index.tabs[pageKey]?.includes(tab)) {
+    return createJsonResponse(
+      {
+        error: `Tab '${tab}' not found for page '${page}' in section '${section}' for version '${version}'`,
+      },
+      404,
+    )
+  }
+
+  // Path is valid, now fetch the actual content
+  const collectionsToFetch = content
+    .filter((entry) => entry.version === version)
+    .map((entry) => entry.name as CollectionKey)
+
+  const collections = await Promise.all(
+    collectionsToFetch.map((name) => getCollection(name)),
+  )
+
+  const flatEntries = collections.flat().map(({ data, filePath, ...rest }) => ({
+    filePath,
+    ...rest,
+    data: {
+      ...data,
+      tab: data.tab || data.source || getDefaultTabForApi(filePath),
+    },
+  }))
+
+  // Find the matching entry
+  const matchingEntry = flatEntries.find((entry: ContentEntry) => {
+    const entryTab = addDemosOrDeprecated(entry.data.tab, entry.id)
+    return (
+      entry.data.section === section &&
+      kebabCase(entry.data.id) === page &&
+      entryTab === tab
+    )
+  })
+
+  // This shouldn't happen since we validated with index, but handle it anyway
+  if (!matchingEntry) {
+    // Log warning - indicates index/content mismatch
+    console.warn(
+      `[API Warning] Index exists but content not found: ${version}/${section}/${page}/${tab}. ` +
+        'This may indicate a mismatch between index generation and actual content.',
+    )
+    return createJsonResponse(
+      {
+        error: `Content not found for tab '${tab}' in page '${page}', section '${section}', version '${version}'`,
+      },
+      404,
+    )
+  }
+
+  // Get the raw body content (markdown/mdx text)
+  const textContent = matchingEntry.body || ''
+
+  return createTextResponse(textContent)
+}

package/src/pages/api/[version]/[section]/[page].ts

@@ -0,0 +1,38 @@
+import type { APIRoute } from 'astro'
+import { createJsonResponse, createIndexKey } from '../../../../utils/apiHelpers'
+import { fetchApiIndex } from '../../../../utils/apiIndex/fetch'
+
+export const prerender = false
+
+export const GET: APIRoute = async ({ params, url }) => {
+  const { version, section, page } = params
+
+  if (!version || !section || !page) {
+    return createJsonResponse(
+      { error: 'Version, section, and page parameters are required' },
+      400,
+    )
+  }
+
+  try {
+    const index = await fetchApiIndex(url)
+    const key = createIndexKey(version, section, page)
+    const tabs = index.tabs[key]
+
+    if (!tabs) {
+      return createJsonResponse(
+        {
+          error: `Page '${page}' not found in section '${section}' for version '${version}'`,
+        },
+        404,
+      )
+    }
+
+    return createJsonResponse(tabs)
+  } catch (error) {
+    return createJsonResponse(
+      { error: 'Failed to load API index', details: error },
+      500
+    )
+  }
+}

package/src/pages/api/[version]/[section].ts

@@ -0,0 +1,37 @@
+import type { APIRoute } from 'astro'
+import { createJsonResponse, createIndexKey } from '../../../utils/apiHelpers'
+import { fetchApiIndex } from '../../../utils/apiIndex/fetch'
+
+export const prerender = false
+
+export const GET: APIRoute = async ({ params, url }) => {
+  const { version, section } = params
+
+  if (!version || !section) {
+    return createJsonResponse(
+      { error: 'Version and section parameters are required' },
+      400,
+    )
+  }
+
+  try {
+    const index = await fetchApiIndex(url)
+    const key = createIndexKey(version, section)
+    const pages = index.pages[key]
+
+    if (!pages) {
+      return createJsonResponse(
+        { error: `Section '${section}' not found for version '${version}'` },
+        404,
+      )
+    }
+
+    return createJsonResponse(pages)
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error)
+    return createJsonResponse(
+      { error: 'Failed to load API index', details },
+      500
+    )
+  }
+}

package/src/pages/api/[version].ts

@@ -0,0 +1,32 @@
+import type { APIRoute } from 'astro'
+import { createJsonResponse } from '../../utils/apiHelpers'
+import { fetchApiIndex } from '../../utils/apiIndex/fetch'
+
+export const prerender = false
+
+export const GET: APIRoute = async ({ params, url }) => {
+  const { version } = params
+
+  if (!version) {
+    return createJsonResponse(
+      { error: 'Version parameter is required' },
+      400,
+    )
+  }
+
+  try {
+    const index = await fetchApiIndex(url)
+    const sections = index.sections[version]
+
+    if (!sections) {
+      return createJsonResponse({ error: `Version '${version}' not found` }, 404)
+    }
+
+    return createJsonResponse(sections)
+  } catch (error) {
+    return createJsonResponse(
+      { error: 'Failed to load API index', details: error },
+      500
+    )
+  }
+}

package/src/pages/api/index.ts

@@ -0,0 +1,172 @@
+import type { APIRoute } from 'astro'
+import { createJsonResponse } from '../../utils/apiHelpers'
+
+export const prerender = false
+
+export const GET: APIRoute = async () =>
+  createJsonResponse({
+      name: 'PatternFly Documentation API',
+      description: 'Machine-readable documentation API for LLM agents and MCP servers',
+      version: '1.0.0',
+      baseUrl: '/api',
+      endpoints: [
+        {
+          path: '/api',
+          method: 'GET',
+          description: 'Get API schema and documentation',
+          returns: {
+            type: 'object',
+            description: 'API schema with endpoints and usage information',
+          },
+        },
+        {
+          path: '/api/versions',
+          method: 'GET',
+          description: 'List available documentation versions',
+          returns: {
+            type: 'array',
+            items: 'string',
+            example: ['v6'],
+          },
+        },
+        {
+          path: '/api/openapi.json',
+          method: 'GET',
+          description: 'Get OpenAPI 3.0 specification',
+          returns: {
+            type: 'object',
+            description: 'Full OpenAPI 3.0 specification for this API',
+          },
+        },
+        {
+          path: '/api/{version}',
+          method: 'GET',
+          description: 'List available sections for a specific version',
+          parameters: [
+            {
+              name: 'version',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'v6',
+            },
+          ],
+          returns: {
+            type: 'array',
+            items: 'string',
+            example: ['components', 'layouts', 'utilities'],
+          },
+        },
+        {
+          path: '/api/{version}/{section}',
+          method: 'GET',
+          description: 'List available pages within a section',
+          parameters: [
+            {
+              name: 'version',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'v6',
+            },
+            {
+              name: 'section',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'components',
+            },
+          ],
+          returns: {
+            type: 'array',
+            items: 'string',
+            description: 'Array of kebab-cased page IDs',
+            example: ['alert', 'button', 'card'],
+          },
+        },
+        {
+          path: '/api/{version}/{section}/{page}',
+          method: 'GET',
+          description: 'List available tabs for a page',
+          parameters: [
+            {
+              name: 'version',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'v6',
+            },
+            {
+              name: 'section',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'components',
+            },
+            {
+              name: 'page',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'alert',
+            },
+          ],
+          returns: {
+            type: 'array',
+            items: 'string',
+            description: 'Array of tab slugs',
+            example: ['react', 'react-demos', 'html'],
+          },
+        },
+        {
+          path: '/api/{version}/{section}/{page}/{tab}',
+          method: 'GET',
+          description: 'Get raw markdown/MDX content for a specific tab',
+          parameters: [
+            {
+              name: 'version',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'v6',
+            },
+            {
+              name: 'section',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'components',
+            },
+            {
+              name: 'page',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'alert',
+            },
+            {
+              name: 'tab',
+              in: 'path',
+              required: true,
+              type: 'string',
+              example: 'react',
+            },
+          ],
+          returns: {
+            type: 'string',
+            contentType: 'text/plain; charset=utf-8',
+            description: 'Raw markdown/MDX documentation content',
+          },
+        },
+      ],
+      usage: {
+        description: 'Navigate the API hierarchically to discover and retrieve documentation',
+        exampleFlow: [
+          'GET /api/versions → ["v6"]',
+          'GET /api/v6 → ["components", "layouts", ...]',
+          'GET /api/v6/components → ["alert", "button", ...]',
+          'GET /api/v6/components/alert → ["react", "html", ...]',
+          'GET /api/v6/components/alert/react → (markdown content)',
+        ],
+      },
+    })