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

package/stl-docs/components/sidebars/convertAstroSidebarToStl.tsx

@@ -0,0 +1,62 @@
+import { StlSidebarEntry } from '@stainless-api/docs-ui/components';
+import { SidebarEntry } from '../pagination/util';
+import { ReactNode } from 'react';
+import { Badge, getHttpMethod } from '@stainless-api/ui-primitives';
+import { FunctionIcon } from '@stainless-api/ui-primitives/icons';
+import { BracesIcon } from 'lucide-react';
+
+function getIcon(entry: SidebarEntry): ReactNode | undefined {
+  if (entry.type !== 'link') {
+    return undefined;
+  }
+  const methodAttr = entry.attrs['data-stldocs-method'];
+  const httpMethod = getHttpMethod(methodAttr);
+  if (httpMethod) {
+    return <Badge.HTTP method={httpMethod} iconOnly size="sm" />;
+  }
+
+  // special handling for the webhooks resource overview page
+  if (entry.attrs['data-stldocs-overview'] === 'webhooks') {
+    return (
+      <Badge size="sm" icon={<BracesIcon />} intent="info">
+        {''}
+      </Badge>
+    );
+  }
+
+  // Support empty string as method to show generic "Function" badge
+  else if (methodAttr === '') {
+    return (
+      <Badge size="sm" icon={<FunctionIcon />} intent="info">
+        {''}
+      </Badge>
+    );
+  }
+  return undefined;
+}
+
+export function convertAstroSidebarToStl(entries: SidebarEntry[]): StlSidebarEntry[] {
+  return entries.map((entry): StlSidebarEntry => {
+    if (entry.type === 'link') {
+      const icon = getIcon(entry);
+      return {
+        type: 'link',
+        attrs: entry.attrs,
+        label: entry.label,
+        target: {
+          type: 'href',
+          href: entry.href,
+        },
+        isCurrent: entry.isCurrent,
+        icon,
+      };
+    } else {
+      return {
+        type: 'group',
+        label: entry.label,
+        collapsed: entry.collapsed,
+        entries: convertAstroSidebarToStl(entry.entries),
+      };
+    }
+  });
+}

package/stl-docs/disableCalloutSyntax.ts

@@ -0,0 +1,36 @@
+import type { AstroIntegration } from 'astro';
+import type { StarlightPlugin } from '@astrojs/starlight/types';
+
+export const disableCalloutSyntaxAstroIntegration = {
+  name: 'stl-starlight-remove-callout-syntax',
+  hooks: {
+    'astro:config:setup': ({ config: astroConfig }) => {
+      // Remove starlight callout syntax in favor of our own callout component
+      // updateConfig always deeply merges arrays so we need to mutate remarkPlugins directly
+      // in order to remove plugins that starlight added
+      astroConfig.markdown.remarkPlugins = astroConfig.markdown.remarkPlugins.filter((plugin, i, arr) => {
+        if (typeof plugin !== 'function') return true;
+        // remove:
+        // 1. remarkDirective plugin
+        if (plugin.name === 'remarkDirective') return false;
+        // 2. directly followed by remarkAsides plugin (inner function named 'attacher')
+        if (plugin.name === 'attacher') {
+          const prev = arr[i - 1];
+          if (typeof prev === 'function' && prev.name === 'remarkDirective') return false;
+        }
+        // 3. remarkDirectivesRestoration plugin
+        if (plugin.name === 'remarkDirectivesRestoration') return false;
+        return true;
+      });
+    },
+  },
+} satisfies AstroIntegration;
+
+export const disableCalloutSyntaxStarlightPlugin = {
+  name: 'stl-starlight-remove-callout-syntax',
+  hooks: {
+    'config:setup': ({ addIntegration }) => {
+      addIntegration(disableCalloutSyntaxAstroIntegration);
+    },
+  },
+} satisfies StarlightPlugin;

package/stl-docs/fonts.ts

@@ -0,0 +1,186 @@
+import type { AstroConfig } from 'astro';
+import type { Defined } from './loadStlDocsConfig';
+import { fontProviders } from 'astro/config';
+import type { FontPreloadFilter } from 'astro:assets';
+
+type AstroFontConfigEntry = Defined<AstroConfig['experimental']['fonts']>[number];
+
+// Apply Omit to each member of the union while preserving union structure
+type PreloadFilter = { preload?: FontPreloadFilter };
+export type StlDocsFontConfigEntry = (AstroFontConfigEntry extends infer T
+  ? T extends unknown
+    ? Omit<T, 'cssVariable'>
+    : never
+  : never) &
+  PreloadFilter;
+
+export type StlDocsFontConfig = {
+  primary?: StlDocsFontConfigEntry;
+  heading?: StlDocsFontConfigEntry;
+  mono?: StlDocsFontConfigEntry;
+  additional?: (AstroFontConfigEntry & PreloadFilter)[];
+};
+const latinFeatureSettings = "'ss01' on, 'ss03' on, 'ss04' on, 'ss06' on, 'ss08' on";
+/* prettier-ignore */
+const latinUnicodeRange: readonly string[] = ['U+0000-00FF', 'U+0131', 'U+0152-0153', 'U+02BB-02BC', 'U+02C6', 'U+02DA', 'U+02DC', 'U+0304', 'U+0308', 'U+0329', 'U+2000-206F', 'U+20AC', 'U+2122', 'U+2191', 'U+2193', 'U+2212', 'U+2215', 'U+FEFF', 'U+FFFD'];
+// /* prettier-ignore */
+// const latinExtUnicodeRange: readonly string[] = ['U+0100-02BA', 'U+02BD-02C5', 'U+02C7-02CC', 'U+02CE-02D7', 'U+02DD-02FF', 'U+0304', 'U+0308', 'U+0329', 'U+1D00-1DBF', 'U+1E00-1E9F', 'U+1EF2-1EFF', 'U+2020', 'U+20A0-20AB', 'U+20AD-20C0', 'U+2113', 'U+2C60-2C7F', 'U+A720-A7FF'];
+
+export function getFontRoles(fonts: StlDocsFontConfig | undefined) {
+  if (!fonts) {
+    return {};
+  }
+  const fontConfigs: {
+    primary?: { cssVariable: string; preload?: FontPreloadFilter };
+    heading?: { cssVariable: string; preload?: FontPreloadFilter };
+    mono?: { cssVariable: string; preload?: FontPreloadFilter };
+    additional?: { cssVariable: string; preload?: FontPreloadFilter }[];
+  } = {};
+  if (fonts.primary) {
+    fontConfigs['primary'] = {
+      cssVariable: '--stl-typography-font' as const,
+      preload: fonts.primary.preload ?? [{ style: 'normal' }],
+    };
+  }
+  if (fonts.heading) {
+    fontConfigs['heading'] = {
+      cssVariable: '--stl-typography-font-heading' as const,
+      preload: fonts.heading.preload ?? [{ style: 'normal' }],
+    };
+  }
+  if (fonts.mono) {
+    fontConfigs['mono'] = {
+      cssVariable: '--stl-typography-font-mono' as const,
+      preload: fonts.mono.preload ?? [{ style: 'normal' }],
+    };
+  }
+  if (fonts.additional) {
+    fontConfigs['additional'] = fonts.additional.map((font) => ({
+      cssVariable: font.cssVariable,
+      preload: font.preload ?? [{ style: 'normal' }],
+    }));
+  }
+  return fontConfigs;
+}
+
+export function normalizeFonts(fonts: StlDocsFontConfig | undefined): StlDocsFontConfig {
+  const defaultPrimary: StlDocsFontConfigEntry = {
+    provider: fontProviders.local(),
+    name: 'Geist',
+    display: 'swap',
+    preload: [
+      {
+        weight: '100 900',
+        style: 'normal',
+      },
+    ],
+    options: {
+      variants: [
+        {
+          weight: '100 900',
+          style: 'normal',
+          src: [new URL('../assets/fonts/geist/geist-latin.woff2', import.meta.url)],
+          unicodeRange: latinUnicodeRange,
+          featureSettings: latinFeatureSettings,
+        },
+        {
+          weight: '100 900',
+          style: 'italic',
+          src: [new URL('../assets/fonts/geist/geist-italic-latin.woff2', import.meta.url)],
+          unicodeRange: latinUnicodeRange,
+          featureSettings: latinFeatureSettings,
+        },
+        // {
+        //   weight: '100 900',
+        //   style: 'normal',
+        //   src: [new URL('../assets/fonts/geist/geist-latin-ext.woff2', import.meta.url)],
+        //   unicodeRange: latinExtUnicodeRange,
+        //   featureSettings: latinFeatureSettings,
+        // },
+        // {
+        //   weight: '100 900',
+        //   style: 'italic',
+        //   src: [new URL('../assets/fonts/geist/geist-italic-latin-ext.woff2', import.meta.url)],
+        //   unicodeRange: latinExtUnicodeRange,
+        //   featureSettings: latinFeatureSettings,
+        // },
+      ],
+    },
+  };
+  const defaultMono: StlDocsFontConfigEntry = {
+    provider: fontProviders.local(),
+    name: 'Geist Mono',
+    display: 'swap',
+    preload: [
+      {
+        weight: '100 900',
+        style: 'normal',
+      },
+    ],
+    options: {
+      variants: [
+        {
+          weight: '100 900',
+          style: 'normal',
+          src: [new URL('../assets/fonts/geist/geist-mono-latin.woff2', import.meta.url)],
+          unicodeRange: latinUnicodeRange,
+        },
+        {
+          weight: '100 900',
+          style: 'italic',
+          src: [new URL('../assets/fonts/geist/geist-mono-italic-latin.woff2', import.meta.url)],
+          unicodeRange: latinUnicodeRange,
+        },
+        // {
+        //   weight: '100 900',
+        //   style: 'normal',
+        //   src: [new URL('../assets/fonts/geist/geist-mono-latin-ext.woff2', import.meta.url)],
+        //   unicodeRange: latinExtUnicodeRange,
+        // },
+        // {
+        //   weight: '100 900',
+        //   style: 'italic',
+        //   src: [new URL('../assets/fonts/geist/geist-mono-italic-latin-ext.woff2', import.meta.url)],
+        //   unicodeRange: latinExtUnicodeRange,
+        // },
+      ],
+    },
+  };
+
+  return {
+    primary: fonts?.primary ?? defaultPrimary,
+    heading: fonts?.heading ?? undefined,
+    mono: fonts?.mono ?? defaultMono,
+    additional: fonts?.additional ?? [],
+  };
+}
+
+// Normalize fonts for the Astro config
+export function flattenFonts(fonts: StlDocsFontConfig | undefined): AstroFontConfigEntry[] {
+  if (!fonts) {
+    return [];
+  }
+  const fontConfigs: AstroFontConfigEntry[] = [];
+  if (fonts.primary) {
+    fontConfigs.push({
+      ...fonts.primary,
+      cssVariable: '--stl-typography-font' as const,
+    } as AstroFontConfigEntry);
+  }
+  if (fonts.heading) {
+    fontConfigs.push({
+      ...fonts.heading,
+      cssVariable: '--stl-typography-font-heading' as const,
+    } as AstroFontConfigEntry);
+  }
+  if (fonts.mono) {
+    fontConfigs.push({
+      ...fonts.mono,
+      cssVariable: '--stl-typography-font-mono' as const,
+    } as AstroFontConfigEntry);
+  }
+  if (fonts.additional) {
+    fontConfigs.push(...fonts.additional.map((font) => font as AstroFontConfigEntry));
+  }
+  return fontConfigs;
+}

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)
@@ -41,13 +49,43 @@ function stainlessDocsStarlightIntegration(config: NormalizedStainlessDocsConfig
 
   type ComponentOverrides = StarlightConfigDefined['components'];
   const componentOverrides: ComponentOverrides = {
-    Search: '@stainless-api/docs/Search',
-    Sidebar: '@stainless-api/docs/Sidebar',
-    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) {
+    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`);
@@ -56,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,
@@ -79,64 +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: [stainlessStarlight(config.apiReference), ...config.starlightCompat.plugins],
+    },
+    plugins,
   });
 }
 
-function stainlessDocsIntegration(config: NormalizedStainlessDocsConfig): AstroIntegration {
-  const virtualId = `virtual:stl-stl-starlight-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: {
             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 > @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,
@@ -147,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',
@@ -158,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
@@ -166,9 +265,26 @@ export function stainlessDocs(config: StainlessDocsUserConfig) {
     process.exit(1);
   }
   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),
   ];
 }