@patternfly/patternfly-doc-core 1.21.0 → 1.21.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@patternfly/patternfly-doc-core",
   "type": "module",
-  "version": "1.21.0",
+  "version": "1.21.2",
   "description": "PatternFly Core Documentation",
   "publishConfig": {
     "access": "public"

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

@@ -1,7 +1,7 @@
  
 import type { APIRoute, GetStaticPaths } from 'astro'
-import { readFile } from 'fs/promises'
-import { resolve } from 'path'
+import { access, readFile } from 'fs/promises'
+import { isAbsolute, resolve } from 'path'
 import { createJsonResponse, createTextResponse } from '../../../../../../../utils/apiHelpers'
 import { generateAndWriteApiIndex } from '../../../../../../../utils/apiIndex/generate'
 import { getEnrichedCollections } from '../../../../../../../utils/apiRoutes/collections'
@@ -66,23 +66,38 @@ export const GET: APIRoute = async ({ params }) => {
 
   try {
     const collections = await getEnrichedCollections(version)
-    const contentEntryFilePath = findContentEntryFilePath(collections, {
+    const contentEntryMatch = findContentEntryFilePath(collections, {
       section,
       page,
       tab
     })
 
-    if (!contentEntryFilePath) {
+    if (!contentEntryMatch) {
       return createJsonResponse(
         { error: `Content entry not found for ${version}/${section}/${page}/${tab}` },
         404
       )
     }
 
+    const { filePath: contentEntryFilePath, base } = contentEntryMatch
+
+    // Resolve the content entry file path.
+    // In non-monorepo setups, filePath is relative to CWD and resolves directly.
+    // In monorepo setups, filePath may be relative to `base` instead of CWD.
+    // We try the original path first, then fall back to resolve(base, filePath).
+    let resolvedContentPath = contentEntryFilePath
+    if (base && !isAbsolute(contentEntryFilePath)) {
+      try {
+        await access(contentEntryFilePath)
+      } catch {
+        resolvedContentPath = resolve(base, contentEntryFilePath)
+      }
+    }
+
     // Read content entry file to extract imports
     let contentEntryFileContent: string
     try {
-      contentEntryFileContent = await readFile(contentEntryFilePath, 'utf8')
+      contentEntryFileContent = await readFile(resolvedContentPath, 'utf8')
     } catch (error) {
       const details = error instanceof Error ? error.message : String(error)
       return createJsonResponse(
@@ -110,8 +125,8 @@ export const GET: APIRoute = async ({ params }) => {
     // Strip query parameters (like ?raw) from the file path before reading
     const cleanFilePath = relativeExampleFilePath.split('?')[0]
 
-    // Read example file
-    const absoluteExampleFilePath = resolve(contentEntryFilePath, '../', cleanFilePath)
+    // Read example file, resolving relative to the content entry file's directory
+    const absoluteExampleFilePath = resolve(resolvedContentPath, '../', cleanFilePath)
     let exampleFileContent: string
     try {
       exampleFileContent = await readFile(absoluteExampleFilePath, 'utf8')

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

@@ -1,13 +1,13 @@
 import type { APIRoute } from 'astro'
+import { pascalCase } from 'change-case'
+
 import { createJsonResponse } from '../../../../../utils/apiHelpers'
-import { getConfig } from '../../../../../../cli/getConfig'
-import { join } from 'node:path'
-import { readFileSync } from 'node:fs'
-import { sentenceCase, removeSubsection } from '../../../../../utils/case'
+import { fetchProps } from '../../../../../utils/propsData/fetch'
+import { removeSubsection } from '../../../../../utils/case'
 
 export const prerender = false
 
-export const GET: APIRoute = async ({ params }) => {
+export const GET: APIRoute = async ({ params, url }) => {
   const { page } = params
 
   if (!page) {
@@ -18,14 +18,8 @@ export const GET: APIRoute = async ({ params }) => {
   }
 
   try {
-    const config = await getConfig(`${process.cwd()}/pf-docs.config.mjs`)
-    const outputDir = config?.outputDir || join(process.cwd(), 'dist')
-
-    const propsFilePath = join(outputDir, 'props.json')
-    const propsDataFile = readFileSync(propsFilePath)
-    const props = JSON.parse(propsDataFile.toString())
-
-    const propsData = props[sentenceCase(removeSubsection(page))]
+    const props = await fetchProps(url)
+    const propsData = props[pascalCase(removeSubsection(page))]
 
     if (propsData === undefined) {
       return createJsonResponse(
@@ -39,11 +33,8 @@ export const GET: APIRoute = async ({ params }) => {
   } catch (error) {
     const details = error instanceof Error ? error.message : String(error)
     return createJsonResponse(
-      { error: 'Props data not found', details },
+      { error: 'Failed to load props data', details },
       500,
     )
   }
 }
-
-
-

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

@@ -1,19 +1,12 @@
 import type { APIRoute } from 'astro'
 import { createJsonResponse } from '../../../../utils/apiHelpers'
-import { getConfig } from '../../../../../cli/getConfig'
-import { join } from 'node:path'
-import { readFileSync } from 'node:fs'
+import { fetchProps } from '../../../../utils/propsData/fetch'
 
 export const prerender = false
 
-export const GET: APIRoute = async ({ }) => {
+export const GET: APIRoute = async ({ url }) => {
   try {
-    const config = await getConfig(`${process.cwd()}/pf-docs.config.mjs`)
-    const outputDir = config?.outputDir || join(process.cwd(), 'dist')
-
-    const propsFilePath = join(outputDir, 'props.json')
-    const propsDataFile = readFileSync(propsFilePath)
-    const props = JSON.parse(propsDataFile.toString())
+    const props = await fetchProps(url)
 
     const propsKey = new RegExp("Props", 'i'); // ignore ComponentProps objects
     const names = Object.keys(props).filter(name => !propsKey.test(name))
@@ -27,6 +20,3 @@ export const GET: APIRoute = async ({ }) => {
     )
   }
 }
-
-
-

package/src/pages/props.json.ts

@@ -0,0 +1,25 @@
+import type { APIRoute } from 'astro'
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+import { getOutputDir } from '../utils/getOutputDir'
+
+// Prerender at build time so this doesn't run in the Cloudflare Worker
+export const prerender = true
+
+export const GET: APIRoute = async () => {
+  try {
+    const outputDir = await getOutputDir()
+    const propsFilePath = join(outputDir, 'props.json')
+    const propsData = await readFile(propsFilePath, 'utf-8')
+
+    return new Response(propsData, {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error)
+    throw new Error(`Failed to prerender /props.json: ${details}`)
+  }
+}

package/src/pages/props.ts

@@ -1,21 +1,31 @@
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { getConfig } from '../../cli/getConfig'
+import { fetchProps } from '../utils/propsData/fetch'
+import { createJsonResponse } from '../utils/apiHelpers'
 
 export const prerender = false
 
 export async function GET({ request }: { request: Request }) {
-  const config = await getConfig(`${process.cwd()}/pf-docs.config.mjs`)
-  const outputDir = config?.outputDir || join(process.cwd(), 'dist')
+  const url = new URL(request.url)
 
-  const propsFilePath = join(outputDir, 'props.json')
-  const propsDataFile = readFileSync(propsFilePath)
-  const props = JSON.parse(propsDataFile.toString())
+  const components = url.searchParams.get('components')
+  if (!components) {
+    return createJsonResponse(
+      { error: 'components query parameter is required' },
+      400,
+    )
+  }
 
-  const queryParams = new URL(request.url).searchParams
-  const components = queryParams.get('components')
-  const componentsArray = components?.split(',')
-  const propsData = componentsArray?.map((component) => props[component])
+  try {
+    const props = await fetchProps(url)
+    const propsData = components
+      .split(',')
+      .map((component) => props[component.trim()])
 
-  return new Response(JSON.stringify(propsData))
+    return createJsonResponse(propsData)
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error)
+    return createJsonResponse(
+      { error: 'Failed to load props data', details },
+      500,
+    )
+  }
 }

package/src/utils/apiRoutes/collections.ts

@@ -5,6 +5,7 @@ import { getDefaultTabForApi } from '../packageUtils'
 
 export type EnrichedContentEntry = {
   filePath: string
+  base?: string
   data: {
     tab: string
     [key: string]: any
@@ -20,20 +21,22 @@ export type EnrichedContentEntry = {
  * @returns Promise resolving to array of collection entries with enriched metadata
  */
 export async function getEnrichedCollections(version: string): Promise<EnrichedContentEntry[]> {
-  const collectionsToFetch = content
-    .filter((entry) => entry.version === version)
-    .map((entry) => entry.name as CollectionKey)
+  const contentEntries = content.filter((entry) => entry.version === version)
 
   const collections = await Promise.all(
-    collectionsToFetch.map((name) => getCollection(name))
+    contentEntries.map((entry) => getCollection(entry.name as CollectionKey))
   )
 
-  return collections.flat().map(({ data, filePath, ...rest }) => ({
-    filePath,
-    ...rest,
-    data: {
-      ...data,
-      tab: data.tab || data.source || getDefaultTabForApi(filePath),
-    },
-  }))
+  return collections.flatMap((collectionEntries, index) => {
+    const base = contentEntries[index].base
+    return collectionEntries.map(({ data, filePath = '', ...rest }) => ({
+      filePath,
+      base,
+      ...rest,
+      data: {
+        ...data,
+        tab: data.tab || data.source || getDefaultTabForApi(filePath),
+      },
+    }))
+  })
 }

package/src/utils/apiRoutes/contentMatching.ts

@@ -66,12 +66,12 @@ export function findContentEntry(
  * @param entries - Array of enriched content entries to search
  * @param params - Parameters to match against (section, page, tab)
  *   - page may be underscore-separated for subsection pages (e.g., "forms_checkbox")
- * @returns The file path, or null if not found
+ * @returns Object with filePath and optional base, or null if not found
  */
 export function findContentEntryFilePath(
   entries: EnrichedContentEntry[],
   params: ContentMatchParams
-): string | null {
+): { filePath: string; base?: string } | null {
   // Find all matching entries using shared matching logic
   const matchingEntries = entries.filter((entry) => matchesParams(entry, params))
 
@@ -83,5 +83,5 @@ export function findContentEntryFilePath(
   const mdxEntry = matchingEntries.find((entry) => entry.filePath.endsWith('.mdx'))
   const selectedEntry = mdxEntry || matchingEntries[0]
 
-  return selectedEntry.filePath
+  return { filePath: selectedEntry.filePath, base: selectedEntry.base }
 }

package/src/utils/propsData/fetch.ts

@@ -0,0 +1,17 @@
+/**
+ * Fetches the props data from the server as a static asset
+ * Used by API routes at runtime instead of reading from the filesystem
+ *
+ * @param url - The URL object from the API route context
+ * @returns Promise resolving to the props data structure
+ */
+export async function fetchProps(url: URL): Promise<Record<string, any>> {
+  const propsUrl = new URL('/props.json', url.origin)
+  const response = await fetch(propsUrl)
+
+  if (!response.ok) {
+    throw new Error(`Failed to load props data: ${response.status} ${response.statusText}`)
+  }
+
+  return await response.json()
+}

package/dist/docs/_worker.js/chunks/getConfig_DO3RhTb7.mjs

@@ -1,18 +0,0 @@
-globalThis.process ??= {}; globalThis.process.env ??= {};
-async function getConfig(fileLocation) {
-  try {
-    const { config } = await import(fileLocation);
-    return config;
-  } catch (e) {
-    if (["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"].includes(e.code)) {
-      console.error(
-        "pf-docs.config.mjs not found, have you created it at the root of your package?"
-      );
-      return;
-    }
-    console.error(e);
-    return;
-  }
-}
-
-export { getConfig as g };