@stainless-api/docs 0.1.0-beta.6 → 0.1.0-beta.61

package/stl-docs/index.ts

@@ -1,6 +1,8 @@
 import starlight from '@astrojs/starlight';
 import react from '@astrojs/react';
+import type { StarlightPlugin } from '@astrojs/starlight/types';
 import { stainlessStarlight } from '../plugin';
+import { disableCalloutSyntaxStarlightPlugin } from './disableCalloutSyntax';
 
 import type { AstroIntegration } from 'astro';
 
@@ -16,11 +18,16 @@ 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 { stainlessDocsProseIndexing } from './proseSearchIndexing';
 
 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 +47,39 @@ 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'),
+    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,
+      }),
+    );
+    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 +88,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,68 +113,100 @@ 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 {
+  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,
+        ENABLE_PROSE_MARKDOWN_RENDERING: config.enableProseMarkdownRendering,
+        // TODO: do not duplicate this between both virtual modules
+        ENABLE_CONTEXT_MENU: config.contextMenu,
+        RENDER_PAGE_DESCRIPTIONS: config.renderPageDescriptions,
+      } 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;`,
+    }),
+  );
+
   // 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);
         }
 
         updateConfig({
           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,
-                    });
-                  }
+                  const bare = id.replace(/^\0/, '');
+                  if (virtualModules.has(bare)) return virtualModules.get(bare);
                 },
               },
             ],
+            optimizeDeps: {
+              include: config.aiChat
+                ? [
+                    '@stainless-api/docs-ai-chat > motion',
+                    '@stainless-api/docs-ai-chat > react-markdown',
+                    '@stainless-api/docs-ai-chat > react-syntax-highlighter',
+                  ]
+                : [],
+            },
           },
           build: {
             ...astroConfig.build,
@@ -158,7 +217,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',
@@ -169,6 +228,17 @@ function stainlessDocsIntegration(config: NormalizedStainlessDocsConfig): AstroI
   };
 }
 
+function sharedLoggerIntegration(): AstroIntegration {
+  return {
+    name: 'stainless',
+    hooks: {
+      'astro:config:setup': ({ logger }) => {
+        setSharedLogger(logger);
+      },
+    },
+  };
+}
+
 export function stainlessDocs(config: StainlessDocsUserConfig) {
   const normalizedConfigResult = parseStlDocsConfig(config);
   if (normalizedConfigResult.result === 'error') {
@@ -178,9 +248,21 @@ 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 }),
+    stainlessDocsProseIndexing(),
   ];
 }

package/stl-docs/loadStlDocsConfig.ts

@@ -1,5 +1,5 @@
 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';
@@ -32,6 +32,7 @@ type PassThroughStarlightConfigOptions = Pick<
   | 'lastUpdated'
   | 'pagination'
   | 'sidebar'
+  | 'expressiveCode'
 >;
 
 type ExperimentalStarlightCompatibilityConfig = Pick<
@@ -45,7 +46,8 @@ type Tabs = {
   sidebar?: SidebarEntry[];
   /**
    * Whether to hide the tab in the tab bar.
-   * Defaults to `false`.
+   *
+   * @default false
    */
   hidden?: boolean;
 }[];
@@ -67,7 +69,32 @@ export type StainlessDocsUserConfig = {
   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 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';
@@ -119,6 +146,12 @@ 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,
     },
     starlightCompat: {
       components: userConfig.experimental?.starlightCompat?.components ?? {},
@@ -128,6 +161,13 @@ function normalizeConfig(userConfig: StainlessDocsUserConfig) {
     enableClientRouter: userConfig.experimental?.enableClientRouter ?? false,
     apiReference: userConfig.apiReference ?? null,
     sidebar: userConfig.sidebar,
+    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,
   };
 
   return configWithDefaults;
@@ -136,11 +176,11 @@ 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 
+ - 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)
  - We prefer empty arrays over undefined/null
 */

package/stl-docs/proseMarkdown/proseMarkdownIntegration.ts

@@ -0,0 +1,64 @@
+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';
+
+export function stainlessDocsMarkdownRenderer({ enabled }: { enabled: boolean }): 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 ({ assets, logger: localLogger, dir }) => {
+        const logger = getSharedLogger({ fallback: localLogger });
+        if (!enabled) {
+          logger.info('Stainless Docs prose Markdown rendering is disabled, skipping...');
+          return;
+        }
+        const starlightPagePatterns = ['/[...slug]'];
+        const pagesToRender = Array.from(assets.entries())
+          .filter(([k]) => {
+            if (starlightPagePatterns.includes(k)) {
+              return true;
+            }
+            return false;
+          })
+          .map(([, v]) => v)
+          .flat()
+          .map((v) => v.pathname);
+
+        logger.info(bold(`Building ${pagesToRender.length} Markdown pages for prose content`));
+
+        const outputBasePath = dir.pathname;
+
+        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,34 @@
+import { defineMiddleware } from 'astro:middleware';
+import { toMarkdown } from './toMarkdown';
+import { API_REFERENCE_BASE_PATH } from 'virtual:stl-docs-virtual-module';
+
+// 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();
+  }
+
+  if (API_REFERENCE_BASE_PATH && context.url.pathname.startsWith(API_REFERENCE_BASE_PATH)) {
+    // handled by the API reference API route in stl-starlight plugin
+    return next();
+  }
+
+  if (!context.url.pathname.endsWith('/index.md')) {
+    return next();
+  }
+
+  const htmlUrl = new URL(context.url.pathname.replace('index.md', ''), 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 });
+});

package/stl-docs/proseMarkdown/toMarkdown.ts

@@ -0,0 +1,158 @@
+import { unified } from 'unified';
+import rehypeParse from 'rehype-parse';
+import rehypeRemark from 'rehype-remark';
+import remarkGfm from 'remark-gfm';
+import remarkStringify from 'remark-stringify';
+import { HTMLElement, parse } from 'node-html-parser';
+
+type PaginationLink = {
+  href: string;
+  label: string;
+};
+
+type PaginationItems = {
+  prev: PaginationLink | null;
+  next: PaginationLink | null;
+};
+
+function parsePaginationLink(footer: HTMLElement, rel: 'next' | 'prev'): PaginationLink | null {
+  const link = footer.querySelector(`.pagination-links a[rel="${rel}"]`);
+  if (!link) {
+    return null;
+  }
+
+  const title = link.querySelector('.link-title');
+  if (!title) {
+    return null;
+  }
+
+  const href = link.getAttribute('href');
+  if (!href) {
+    return null;
+  }
+
+  return {
+    href,
+    label: title.text,
+  };
+}
+
+function isRelativeLink(href: string) {
+  return href.startsWith('/');
+}
+
+function hasExtension(href: string) {
+  return href.includes('.');
+}
+
+function removeTrailingSlash(href: string) {
+  return href.replace(/\/$/, '');
+}
+
+function makeMarkdownLinks(el: HTMLElement) {
+  el.querySelectorAll('a').forEach((a) => {
+    const href = a.getAttribute('href');
+    if (!href) {
+      return a;
+    }
+
+    if (isRelativeLink(href) && !hasExtension(href)) {
+      if (href === '/') {
+        a.setAttribute('href', '/index.md');
+      } else {
+        a.setAttribute('href', `${removeTrailingSlash(href)}/index.md`);
+      }
+    }
+    return a;
+  });
+}
+
+function removeHiddenElements(el: HTMLElement) {
+  const hiddenSelectors = ['.sl-anchor-link'];
+  for (const selector of hiddenSelectors) {
+    const hiddenElements = el.querySelectorAll(selector);
+    for (const hiddenElement of hiddenElements) {
+      hiddenElement.remove();
+    }
+  }
+}
+
+export async function toMarkdown(html: string) {
+  const root = parse(html);
+
+  const mainEl = root.querySelector('main');
+
+  if (!mainEl) {
+    return null;
+  }
+
+  makeMarkdownLinks(mainEl);
+
+  const footer = mainEl.querySelector('footer');
+
+  const markdownContentEl = mainEl.querySelector('.sl-markdown-content');
+  if (!markdownContentEl) {
+    return null;
+  }
+
+  removeHiddenElements(markdownContentEl);
+
+  const articleContent = markdownContentEl.innerHTML;
+
+  const paginationLinks: PaginationItems = {
+    prev: null,
+    next: null,
+  };
+
+  if (footer) {
+    paginationLinks.prev = parsePaginationLink(footer, 'prev');
+    paginationLinks.next = parsePaginationLink(footer, 'next');
+  }
+
+  let md = (
+    await unified()
+      .use(rehypeParse, { fragment: true }) // parse HTML
+      .use(rehypeRemark) // rehype (HTML) -> remark (MD AST)
+      .use(remarkGfm) // tables, strikethrough, autolinks, etc.
+      .use(remarkStringify, {
+        fences: true,
+        bullet: '-',
+        listItemIndent: 'one',
+        rule: '-',
+      })
+      .process(articleContent)
+  ).toString();
+
+  const title = root.querySelector('title')?.textContent;
+  const description = root.querySelector('meta[name="description"]')?.attributes.content;
+  const lastUpdated = root.querySelector('.meta time')?.attributes.datetime;
+
+  // let htmlUrl = url.toString().replace('.md', '');
+  // if (htmlUrl.endsWith('/index')) {
+  //   htmlUrl = htmlUrl.replace('/index', '');
+  // }
+
+  md = [
+    '---',
+    `title: ${title}`,
+    description ? `description: ${description}` : [],
+    lastUpdated ? `lastUpdated: ${lastUpdated}` : [],
+    // `source_url:`,
+    // `  html: ${htmlUrl}`,
+    // `  md: ${url.toString()}`,
+    '---\n',
+    md,
+  ]
+    .flat()
+    .join('\n');
+
+  if (paginationLinks.prev) {
+    md += `\n\n[Previous](${paginationLinks.prev.href})`;
+  }
+
+  if (paginationLinks.next) {
+    md += `\n\n[Next](${paginationLinks.next.href})`;
+  }
+
+  return md;
+}