@stainless-api/docs 0.1.0-beta.10 → 0.1.0-beta.100

package/stl-docs/index.ts

@@ -1,6 +1,7 @@
 import starlight from '@astrojs/starlight';
 import react from '@astrojs/react';
-import { stainlessStarlight } from '../plugin';
+import type { StarlightPlugin } from '@astrojs/starlight/types';
+import { disableCalloutSyntaxStarlightPlugin } from './disableCalloutSyntax';
 
 import type { AstroIntegration } from 'astro';
 
@@ -16,11 +17,18 @@ import {
   type StarlightSidebarConfig,
 } from './loadStlDocsConfig';
 import { buildVirtualModuleString } from '../shared/virtualModule';
-
-import geistPath from '../plugin/assets/fonts/geist/geist-latin.woff2?url';
+import type * as StlDocsVirtualModule from 'virtual:stl-docs-virtual-module';
+import { resolveSrcFile } from '../resolveSrcFile';
+import { stainlessDocsMarkdownRenderer } from './proseMarkdown/proseMarkdownIntegration';
+import { setSharedLogger } from '../shared/getSharedLogger';
+import { stainlessDocsAlgoliaProseIndexing, stainlessDocsVectorProseIndexing } from './proseSearchIndexing';
+import { stainlessStarlight } from '../plugin';
+import { getFontRoles, flattenFonts } from './fonts';
 
 export * from '../plugin';
 
+const COMPONENTS_FOLDER = '/stl-docs/components';
+
 function stainlessDocsStarlightIntegration(config: NormalizedStainlessDocsConfig) {
   // We transform our tabs into a Starlight sidebar
   // This gives them all the built-in features of Starlight (eg. auto-generated entries by directory)
@@ -40,21 +48,44 @@ function stainlessDocsStarlightIntegration(config: NormalizedStainlessDocsConfig
   }
 
   type ComponentOverrides = StarlightConfigDefined['components'];
-  const plugins = [...config.starlightCompat.plugins];
-
   const componentOverrides: ComponentOverrides = {
-    Sidebar: '@stainless-api/docs/BaseSidebar',
-    Header: '@stainless-api/docs/Header',
-    ThemeSelect: '@stainless-api/docs/ThemeSelect',
-    ContentPanel: '@stainless-api/docs/ContentPanel',
+    PageFrame: resolveSrcFile(COMPONENTS_FOLDER, './PageFrame.astro'),
+
+    Head: resolveSrcFile(COMPONENTS_FOLDER, './Head.astro'),
+    Header: resolveSrcFile(COMPONENTS_FOLDER, './Header.astro'),
+    ThemeProvider: resolveSrcFile(COMPONENTS_FOLDER, './ThemeProvider.astro'),
+    ThemeSelect: resolveSrcFile(COMPONENTS_FOLDER, './ThemeSelect.astro'),
+
+    Sidebar: resolveSrcFile(COMPONENTS_FOLDER, './sidebars/BaseSidebar.astro'),
+    ContentPanel: resolveSrcFile(COMPONENTS_FOLDER, './content-panel/ContentPanel.astro'),
+    TableOfContents: resolveSrcFile(COMPONENTS_FOLDER, './TableOfContents.astro'),
+
+    PageTitle: resolveSrcFile(COMPONENTS_FOLDER, './PageTitle.astro'),
+    Pagination: resolveSrcFile(COMPONENTS_FOLDER, './pagination/Pagination.astro'),
   };
 
+  const plugins: StarlightPlugin[] = [
+    // Disable starlight callout syntax in favor of our own component
+    disableCalloutSyntaxStarlightPlugin,
+  ];
+
   if (config.apiReference !== null) {
-    componentOverrides.Sidebar = '@stainless-api/docs/SDKSelectSidebar';
-    componentOverrides.Search = '@stainless-api/docs/Search';
-    plugins.unshift(stainlessStarlight(config.apiReference));
+    plugins.push(
+      stainlessStarlight({
+        ...config.apiReference,
+        contextMenu: config.contextMenu,
+        experimentalPrerender:
+          config.apiReference.experimentalPrerender === undefined
+            ? config.starlightPassThrough.prerender
+            : config.apiReference.experimentalPrerender,
+      }),
+    );
+    componentOverrides.Sidebar = resolveSrcFile(COMPONENTS_FOLDER, './sidebars/SDKSelectSidebar.astro');
+    componentOverrides.Search = resolveSrcFile('/plugin/components/search/Search.astro');
   }
 
+  plugins.push(...config.starlightCompat.plugins, ...config.plugins.map((p) => p(config)));
+
   // TODO: re-add once we figure out what to do with the client router
   // if (config.enableClientRouter) {
   //   // logger.info(`Client router is enabled`);
@@ -63,6 +94,8 @@ function stainlessDocsStarlightIntegration(config: NormalizedStainlessDocsConfig
   //   // logger.info(`Client router is disabled`);
   // }
 
+  const userExpressiveCode = typeof config.expressiveCode === 'object' ? config.expressiveCode : {};
+
   return starlight({
     ...config.starlightPassThrough,
     sidebar,
@@ -86,69 +119,112 @@ function stainlessDocsStarlightIntegration(config: NormalizedStainlessDocsConfig
         setupNavLinksInitial();
       `,
       },
-      // TODO: for users who are overriding the font stack in their own styles, how can we know that
-      // and preload their font instead of ours?
-      {
-        tag: 'link',
-        attrs: {
-          rel: 'preload',
-          as: 'font',
-          type: 'font/woff2',
-          crossorigin: 'anonymous',
-          href: geistPath,
+    ],
+    routeMiddleware: [
+      ...config.starlightCompat.routeMiddleware,
+      resolveSrcFile('/stl-docs/tabsMiddleware.ts'),
+    ],
+    customCss: [resolveSrcFile('/theme.css'), ...config.customCss],
+
+    expressiveCode: {
+      ...userExpressiveCode,
+      themes: userExpressiveCode.themes ?? ['github-light', 'github-dark'],
+      styleOverrides: {
+        ...userExpressiveCode.styleOverrides,
+        textMarkers: {
+          insBackground: 'var(--stl-color-green-muted-background)',
+          insBorderColor: 'var(--stl-color-green-border)',
+          insDiffIndicatorColor: 'var(--stl-color-green-foreground-reduced)',
+
+          delBackground: 'var(--stl-color-red-muted-background)',
+          delBorderColor: 'var(--stl-color-red-border)',
+          delDiffIndicatorColor: 'var(--stl-color-red-foreground-reduced)',
+
+          markBackground: 'var(--stl-color-blue-muted-background)',
+          markBorderColor: 'var(--stl-color-blue-border)',
+          ...userExpressiveCode.styleOverrides?.textMarkers,
         },
       },
-    ],
-    routeMiddleware: [...config.starlightCompat.routeMiddleware, '@stainless-api/docs/tabsMiddleware'],
-    customCss: ['@stainless-api/docs/theme', ...config.customCss],
+    },
     plugins,
   });
 }
 
-function stainlessDocsIntegration(config: NormalizedStainlessDocsConfig): AstroIntegration {
-  const virtualId = `virtual:stl-docs-virtual-module`;
+function stainlessDocsIntegration(
+  config: NormalizedStainlessDocsConfig,
+  apiReferenceBasePath: string | null,
+): AstroIntegration {
   // The '\0' prefix tells Vite “this is a virtual module” and prevents it from being resolved again.
-  const resolvedId = `\0${virtualId}`;
+  const resolveVirtualModuleId = (id: string) => `\0${id}`;
   let redirects: NormalizedRedirectConfig | null = null;
 
   return {
-    name: 'stl-docs-integration',
+    name: 'stl-docs-astro',
     hooks: {
       'astro:config:setup': ({ updateConfig, command, config: astroConfig }) => {
-        // // we only handle redirects for builds
-        // // in dev, Astro handles them for us
+        // we only handle redirects for builds
+        // in dev, Astro handles them for us
         if (command === 'build' && astroConfig.redirects) {
           redirects = normalizeRedirects(astroConfig.redirects);
         }
 
+        const virtualModules = new Map(
+          Object.entries({
+            'virtual:stl-docs-virtual-module': buildVirtualModuleString({
+              TABS: config.tabs,
+              SPLIT_TABS_ENABLED: config.splitTabsEnabled,
+              HEADER_LINKS: config.header.links,
+              HEADER_LAYOUT: config.header.layout,
+              ENABLE_CLIENT_ROUTER: config.enableClientRouter,
+              API_REFERENCE_BASE_PATH: apiReferenceBasePath ?? '/api',
+              ENABLE_PROSE_MARKDOWN_RENDERING: config.enableProseMarkdownRendering,
+              ENABLE_CONTEXT_MENU: config.contextMenu, // TODO: do not duplicate this between both virtual modules
+              RENDER_PAGE_DESCRIPTIONS: config.renderPageDescriptions,
+              FONTS: getFontRoles(config.fonts),
+              LINK_GROUP_TITLES_TO_OVERVIEW_PAGES: config.linkGroupTitlesToOverviewPages,
+            } satisfies typeof StlDocsVirtualModule),
+
+            'virtual:stl-docs/components/AiChat.tsx': `
+        ${
+          config.aiChat
+            ? `export { default } from ${JSON.stringify(config.aiChat.chatComponentPath)};`
+            : // export null when no AI chat component is provided
+              `export default null;`
+        }
+        export const STAINLESS_PROJECT = ${config.apiReference ? JSON.stringify(config.apiReference.stainlessProject) : 'undefined'};
+      `,
+          }),
+        );
+
         updateConfig({
+          experimental: {
+            fonts: [...flattenFonts(config.fonts), ...(astroConfig.experimental?.fonts ?? [])],
+          },
           vite: {
-            ssr: {
-              noExternal: ['@stainless-api/ui-primitives'],
-            },
-            optimizeDeps: { include: ['@stainless-api/ui-primitives'] },
             plugins: [
               {
                 name: 'stl-docs-vite',
                 resolveId(id) {
-                  if (id === virtualId) {
-                    return resolvedId;
-                  }
+                  if (virtualModules.has(id)) return resolveVirtualModuleId(id);
                 },
                 load(id) {
-                  if (id === resolvedId) {
-                    return buildVirtualModuleString({
-                      TABS: config.tabs,
-                      SPLIT_TABS_ENABLED: config.splitTabsEnabled,
-                      HEADER_LINKS: config.header.links,
-                      HEADER_LAYOUT: config.header.layout,
-                      ENABLE_CLIENT_ROUTER: config.enableClientRouter,
-                      INCLUDE_AI_DROPDOWN_OPTIONS: config.includeAIDropdownOptions,
-                    });
-                  }
+                  const bare = id.replace(/^\0/, '');
+                  if (virtualModules.has(bare)) return virtualModules.get(bare);
                 },
               },
             ],
+            optimizeDeps: {
+              include: config.aiChat
+                ? [
+                    '@stainless-api/docs-ai-chat > @stainless-api/ai-chat > lucide-react',
+                    '@stainless-api/docs-ai-chat > @stainless-api/ai-chat > motion',
+                    '@stainless-api/docs-ai-chat > @stainless-api/ai-chat > motion > framer-motion',
+                    '@stainless-api/docs-ai-chat > @stainless-api/ai-chat > react-markdown',
+                    '@stainless-api/docs-ai-chat > @stainless-api/ai-chat > react-syntax-highlighter',
+                    '@stainless-api/docs-ai-chat > @stainless-api/ai-chat > remark-gfm',
+                  ]
+                : [],
+            },
           },
           build: {
             ...astroConfig.build,
@@ -159,7 +235,7 @@ function stainlessDocsIntegration(config: NormalizedStainlessDocsConfig): AstroI
       'astro:build:done': ({ dir }) => {
         if (redirects !== null) {
           const stainlessDir = join(dir.pathname, '_stainless');
-          mkdirSync(stainlessDir);
+          mkdirSync(stainlessDir, { recursive: true });
           const outputPath = join(stainlessDir, 'redirects.json');
           writeFileSync(outputPath, JSON.stringify(redirects, null, 2), {
             encoding: 'utf-8',
@@ -170,7 +246,18 @@ function stainlessDocsIntegration(config: NormalizedStainlessDocsConfig): AstroI
   };
 }
 
-export function stainlessDocs(config: StainlessDocsUserConfig) {
+function sharedLoggerIntegration(): AstroIntegration {
+  return {
+    name: 'stainless',
+    hooks: {
+      'astro:config:setup': ({ logger }) => {
+        setSharedLogger(logger);
+      },
+    },
+  };
+}
+
+export function stainlessDocs(config: StainlessDocsUserConfig): StarlightPlugin[] {
   const normalizedConfigResult = parseStlDocsConfig(config);
   if (normalizedConfigResult.result === 'error') {
     // TODO: would be good to use the astro logger somehow
@@ -179,9 +266,25 @@ export function stainlessDocs(config: StainlessDocsUserConfig) {
   }
   const normalizedConfig = normalizedConfigResult.config;
 
+  // TODO: need to refactor this, but this allows us to get the base path for the API reference _if_ it exists
+  // if it doesn't exist, the value of basePath is null.
+  // the stl-starlight virtual module has base path, but it's not available when there's no API reference
+  const hasApiReference = normalizedConfig.apiReference !== null;
+  let apiReferenceBasePath: string | null = null;
+  if (hasApiReference) {
+    apiReferenceBasePath = normalizedConfig.apiReference?.basePath ?? '/api';
+  }
+
   return [
+    sharedLoggerIntegration(), // this **must** be first so it can set the shared logger used by our other integrations
     react(),
     stainlessDocsStarlightIntegration(normalizedConfig),
-    stainlessDocsIntegration(normalizedConfig),
+    stainlessDocsIntegration(normalizedConfig, apiReferenceBasePath),
+    stainlessDocsMarkdownRenderer({
+      enabled: normalizedConfig.enableProseMarkdownRendering,
+      apiReferenceBasePath,
+    }),
+    stainlessDocsAlgoliaProseIndexing({ apiReferenceBasePath }),
+    stainlessDocsVectorProseIndexing(normalizedConfig, apiReferenceBasePath),
   ];
 }

package/stl-docs/loadStlDocsConfig.ts

@@ -1,8 +1,9 @@
 import type { StainlessStarlightUserConfig } from '../plugin/loadPluginConfig';
-import type { StarlightUserConfig } from '@astrojs/starlight/types';
+import type { StarlightPlugin, StarlightUserConfig } from '@astrojs/starlight/types';
 import type { ButtonVariant } from '@stainless-api/ui-primitives';
 import type { AnchorHTMLAttributes } from 'react';
 import type starlight from '@astrojs/starlight';
+import { normalizeFonts, type StlDocsFontConfig } from './fonts';
 
 type StarlightConfig = Parameters<typeof starlight>[0];
 
@@ -32,20 +33,22 @@ type PassThroughStarlightConfigOptions = Pick<
   | 'lastUpdated'
   | 'pagination'
   | 'sidebar'
+  | 'expressiveCode'
 >;
 
 type ExperimentalStarlightCompatibilityConfig = Pick<
   StarlightConfigDefined,
-  'components' | 'routeMiddleware' | 'plugins'
+  'components' | 'routeMiddleware' | 'plugins' | 'prerender'
 >;
 
-type Tabs = {
+export type Tabs = {
   label: string;
   link: string;
   sidebar?: SidebarEntry[];
   /**
    * Whether to hide the tab in the tab bar.
-   * Defaults to `false`.
+   *
+   * @default false
    */
   hidden?: boolean;
 }[];
@@ -64,10 +67,42 @@ export type StainlessDocsUserConfig = {
     layout?: HeaderLayout;
     links?: HeaderLink[];
   };
+  fonts?: StlDocsFontConfig;
   experimental?: {
     starlightCompat?: ExperimentalStarlightCompatibilityConfig;
     enableClientRouter?: boolean;
+    /**
+     * Disable markdown rendering for prose content. Only disable this if it is causing issues.
+     *
+     * @default false
+     */
+    disableProseMarkdownRendering?: boolean;
+    aiChat?: { chatComponentPath: string };
+    /**
+     * Whether to link group titles to overview pages. Note: overview pages must already be present in the sidebar for this to work.
+     *
+     * @default false
+     */
+    linkGroupTitlesToOverviewPages?: boolean;
   };
+  /**
+   * Whether to show the context menu with options like "Copy as Markdown" and "Open in ChatGPT".
+   *
+   * @default true
+   */
+  contextMenu?: boolean;
+
+  /**
+   * Whether to render page descriptions in prose page headers
+   *
+   * @default true
+   */
+  renderPageDescriptions?: boolean;
+  /**
+   * Stainless Docs plugins.
+   * Each plugin is a function that receives the normalized config and returns a Starlight plugin.
+   */
+  plugins?: ((config: Exclude<NormalizedStainlessDocsConfig, 'plugins'>) => StarlightPlugin)[];
 } & PassThroughStarlightConfigOptions;
 
 type HeaderLayout = 'default' | 'stacked';
@@ -112,6 +147,7 @@ function normalizeConfig(userConfig: StainlessDocsUserConfig) {
       layout: userConfig.header?.layout ?? 'default',
       links: userConfig.header?.links ?? [],
     },
+    fonts: normalizeFonts(userConfig.fonts),
     starlightPassThrough: {
       tableOfContents: userConfig.tableOfContents,
       titleDelimiter: userConfig.titleDelimiter,
@@ -119,6 +155,13 @@ function normalizeConfig(userConfig: StainlessDocsUserConfig) {
       description: userConfig.description,
       tagline: userConfig.tagline,
       logo: userConfig.logo,
+      favicon: userConfig.favicon,
+      disable404Route: userConfig.disable404Route,
+      editLink: userConfig.editLink,
+      locales: userConfig.locales,
+      lastUpdated: userConfig.lastUpdated,
+      pagination: userConfig.pagination,
+      prerender: userConfig.experimental?.starlightCompat?.prerender ?? true,
     },
     starlightCompat: {
       components: userConfig.experimental?.starlightCompat?.components ?? {},
@@ -128,7 +171,14 @@ function normalizeConfig(userConfig: StainlessDocsUserConfig) {
     enableClientRouter: userConfig.experimental?.enableClientRouter ?? false,
     apiReference: userConfig.apiReference ?? null,
     sidebar: userConfig.sidebar,
-    includeAIDropdownOptions: userConfig.apiReference?.includeAIDropdownOptions ?? false,
+    enableProseMarkdownRendering:
+      userConfig.experimental?.disableProseMarkdownRendering === true ? false : true,
+    contextMenu: userConfig.contextMenu ?? true,
+    expressiveCode: userConfig.expressiveCode,
+    renderPageDescriptions: userConfig.renderPageDescriptions ?? true,
+    plugins: userConfig.plugins ?? [],
+    aiChat: userConfig.experimental?.aiChat,
+    linkGroupTitlesToOverviewPages: userConfig.experimental?.linkGroupTitlesToOverviewPages ?? false,
   };
 
   return configWithDefaults;
@@ -137,12 +187,12 @@ function normalizeConfig(userConfig: StainlessDocsUserConfig) {
 export type NormalizedStainlessDocsConfig = ReturnType<typeof normalizeConfig>;
 
 /*
- The goal of the code in this file is to take a user's config and normalize it. 
+ The goal of the code in this file is to take a user's config and normalize it.
  Specifically: we want a single complete config format used throughout the internals of the plugin.
 
  We've tried to avoid any config values being optional/undefined. To accomplish this:
- - Any optional config values should have their defaults set here: eg. basePath defaults to /api 
- - If a field is only used in certain contexts, we make each context a discriminated union (see SpecRetrieverConfig)
+ - Any optional config values should have their defaults set here: eg. basePath defaults to /api
+ - If a field is only used in certain contexts, we make each context a discriminated union (see SDKJSONInputs)
  - We prefer empty arrays over undefined/null
 */
 export function parseStlDocsConfig(userConfig: StainlessDocsUserConfig) {

package/stl-docs/proseMarkdown/proseMarkdownIntegration.ts

@@ -0,0 +1,61 @@
+import type { AstroIntegration } from 'astro';
+import { readFile, writeFile } from 'fs/promises';
+import { toMarkdown } from './toMarkdown';
+import { resolveSrcFile } from '../../resolveSrcFile';
+import { getSharedLogger } from '../../shared/getSharedLogger';
+import { bold } from '../../shared/terminalUtils';
+import { getProsePages } from '../../shared/getProsePages';
+
+export function stainlessDocsMarkdownRenderer({
+  enabled,
+  apiReferenceBasePath,
+}: {
+  enabled: boolean;
+  apiReferenceBasePath: string | null;
+}): AstroIntegration {
+  return {
+    name: 'stl-docs-md',
+    hooks: {
+      'astro:config:setup': ({ addMiddleware }) => {
+        if (enabled) {
+          addMiddleware({
+            entrypoint: resolveSrcFile('/stl-docs/proseMarkdown/proseMarkdownMiddleware.ts'),
+            order: 'post',
+          });
+        }
+      },
+      'astro:build:done': async ({ logger: localLogger, dir }) => {
+        const logger = getSharedLogger({ fallback: localLogger });
+        if (!enabled) {
+          logger.info('Stainless Docs prose Markdown rendering is disabled, skipping...');
+          return;
+        }
+        const outputBasePath = dir.pathname;
+        const pagesToRender = await getProsePages({ apiReferenceBasePath, outputBasePath });
+
+        logger.info(bold(`Building ${pagesToRender.length} Markdown pages for prose content`));
+
+        let completedCount = 0;
+
+        for (const absHtmlPath of pagesToRender) {
+          const txt = await readFile(absHtmlPath, 'utf-8');
+          const md = await toMarkdown(txt);
+          if (md) {
+            const absMdPath = absHtmlPath.replace('.html', '.md');
+            await writeFile(absMdPath, md, 'utf-8');
+
+            completedCount++;
+
+            const relHtmlPath = absHtmlPath.replace(outputBasePath, '');
+            const relMdPath = absMdPath.replace(outputBasePath, '');
+
+            logger.info(`(${completedCount}/${pagesToRender.length}) ${relHtmlPath} -> ${relMdPath}`);
+          } else {
+            logger.error(`Failed to render ${absHtmlPath} as Markdown`);
+            process.exit(1);
+          }
+        }
+      },
+    },
+  };
+}

package/stl-docs/proseMarkdown/proseMarkdownMiddleware.ts

@@ -0,0 +1,41 @@
+import { defineMiddleware } from 'astro:middleware';
+import { toMarkdown } from './toMarkdown';
+import { API_REFERENCE_BASE_PATH } from 'virtual:stl-docs-virtual-module';
+import path from 'path';
+
+// this is only run in `astro dev` for rendering prose content as Markdown on the fly.
+export const onRequest = defineMiddleware(async (context, next) => {
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  if (!import.meta.env.DEV) {
+    return next();
+  }
+
+  const resolvedBasePath = path.posix.join(import.meta.env.BASE_URL ?? '', API_REFERENCE_BASE_PATH);
+  if (resolvedBasePath && context.url.pathname.startsWith(resolvedBasePath)) {
+    // handled by the API reference API route in stl-starlight plugin
+    return next();
+  }
+
+  if (!context.url.pathname.endsWith('/index.md')) {
+    return next();
+  }
+
+  const pathname = context.url.pathname.replace('index.md', '');
+
+  // We must trim the trailing slash to support astro configs with `trailingSlash: 'never'`
+  const cleanPathname = pathname !== '/' ? pathname.replace(/\/$/, '') : pathname;
+  const htmlUrl = new URL(cleanPathname, context.url);
+
+  const resp = await fetch(htmlUrl);
+  if (!resp.ok) {
+    return new Response('Failed to fetch HTML', { status: 400 });
+  }
+  const html = await resp.text();
+  const md = await toMarkdown(html);
+
+  if (!md) {
+    return new Response('Failed to render Markdown', { status: 400 });
+  }
+
+  return new Response(md, { status: 200 });
+});