@fullstackdatasolutions/articles 0.8.2 → 0.9.0

package/src/__tests__/markdown.test.ts

@@ -9,11 +9,16 @@ jest.mock('remark-github-blockquote-alert', () => () => () => {})
 jest.mock('remark-parse', () => () => () => {})
 jest.mock('remark-rehype', () => () => () => {})
 
+const mockRemarkUseCalls: unknown[][] = []
+
 // Mock remark() to return a chainable processor whose .process() resolves to ''
 jest.mock('remark', () => {
   const makeChain = (): Record<string, unknown> => {
     const chain: Record<string, unknown> = {
-      use: () => chain,
+      use: (...args: unknown[]) => {
+        mockRemarkUseCalls.push(args)
+        return chain
+      },
       process: async () => ({ toString: () => '' }),
     }
     return chain
@@ -80,8 +85,15 @@ function root(...nodes: HastElement[]): HastRoot {
   return { type: 'root', children: nodes }
 }
 
-function runRenderer(tree: HastRoot) {
-  const transform = (customRenderer as unknown as () => (tree: HastRoot) => void)()
+type LinkTargetOptions = Readonly<{
+  strategy?: 'external-new-tab' | 'all-new-tab' | 'same-tab'
+  siteUrl?: string
+}>
+
+function runRenderer(tree: HastRoot, options?: LinkTargetOptions) {
+  const transform = (
+    customRenderer as unknown as (options?: LinkTargetOptions) => (tree: HastRoot) => void
+  )(options)
   transform(tree)
 }
 
@@ -212,6 +224,13 @@ describe('customRenderer', () => {
       expect(node.properties.rel).toBe('noopener noreferrer')
     })
 
+    it('does NOT add target="_blank" to root-relative internal links by default', () => {
+      const node = el('a', { href: '/internal' })
+      runRenderer(root(node))
+      expect(node.properties.target).toBeUndefined()
+      expect(node.properties.rel).toBeUndefined()
+    })
+
     it('does NOT add target="_blank" to internal anchor links (#)', () => {
       const node = el('a', { href: '#section-id' })
       runRenderer(root(node))
@@ -225,6 +244,46 @@ describe('customRenderer', () => {
       expect(node.properties.target).toBeUndefined()
     })
 
+    it('does NOT add target="_blank" to same-origin absolute links', () => {
+      const node = el('a', { href: 'https://example.com/articles/internal' })
+      runRenderer(root(node), { siteUrl: 'https://example.com' })
+      expect(node.properties.target).toBeUndefined()
+      expect(node.properties.rel).toBeUndefined()
+    })
+
+    it('adds target="_blank" and rel to different-origin absolute links', () => {
+      const node = el('a', { href: 'https://different-site.com' })
+      runRenderer(root(node), { siteUrl: 'https://example.com' })
+      expect(node.properties.target).toBe('_blank')
+      expect(node.properties.rel).toBe('noopener noreferrer')
+    })
+
+    it('opens browser navigation links in a new tab when strategy is all-new-tab', () => {
+      const node = el('a', { href: '/internal' })
+      runRenderer(root(node), { strategy: 'all-new-tab', siteUrl: 'https://example.com' })
+      expect(node.properties.target).toBe('_blank')
+      expect(node.properties.rel).toBe('noopener noreferrer')
+    })
+
+    it('does not open links in a new tab when strategy is same-tab', () => {
+      const node = el('a', { href: 'https://different-site.com' })
+      runRenderer(root(node), { strategy: 'same-tab', siteUrl: 'https://example.com' })
+      expect(node.properties.target).toBeUndefined()
+      expect(node.properties.rel).toBeUndefined()
+    })
+
+    it('leaves mailto and tel links in the same tab', () => {
+      const nodes = [
+        el('a', { href: 'mailto:test@example.com' }),
+        el('a', { href: 'tel:+15555555555' }),
+      ]
+      runRenderer(root(...nodes), { strategy: 'all-new-tab', siteUrl: 'https://example.com' })
+      nodes.forEach((node) => {
+        expect(node.properties.target).toBeUndefined()
+        expect(node.properties.rel).toBeUndefined()
+      })
+    })
+
     it('applies link className to external anchors', () => {
       const node = el('a', { href: 'https://external.com' })
       runRenderer(root(node))
@@ -248,6 +307,10 @@ describe('customRenderer', () => {
 // ---------------------------------------------------------------------------
 
 describe('markdownToHtml', () => {
+  beforeEach(() => {
+    mockRemarkUseCalls.length = 0
+  })
+
   it('returns a string', async () => {
     const result = await markdownToHtml('# Hello')
     expect(typeof result).toBe('string')
@@ -260,6 +323,19 @@ describe('markdownToHtml', () => {
   it('resolves without throwing when articleSlug is provided', async () => {
     await expect(markdownToHtml('![alt](photo.png)', 'my-article')).resolves.toBeDefined()
   })
+
+  it('passes link target config to customRenderer', async () => {
+    await markdownToHtml('# Hello', 'my-article', {
+      siteUrl: 'https://example.com',
+      siteName: 'Example',
+      linkTargetStrategy: 'external-new-tab',
+    })
+
+    expect(mockRemarkUseCalls).toContainEqual([
+      customRenderer,
+      { strategy: 'external-new-tab', siteUrl: 'https://example.com' },
+    ])
+  })
 })
 
 // ---------------------------------------------------------------------------

package/src/__tests__/renderMdx.test.tsx

@@ -179,6 +179,28 @@ describe('renderMdxSource', () => {
       expect(container.querySelector('a[href="#section-one"]')).not.toBeNull()
       expect(container.querySelector('a[href="#section-two"]')).not.toBeNull()
     })
+
+    it('passes link target config into the markdown renderer plugin', async () => {
+      mockEvaluate.mockResolvedValue({
+        default: () => React.createElement('a', { href: 'https://external.com' }, 'External'),
+      })
+      Object.defineProperty(process.env, 'NODE_ENV', { value: 'production', writable: true })
+
+      const config = {
+        siteUrl: 'https://example.com',
+        siteName: 'Example',
+        linkTargetStrategy: 'external-new-tab' as const,
+      }
+      const { renderMdxSource } = await import('../renderMdx')
+      await renderMdxSource('[External](https://external.com)', '/articles/my-article', config)
+
+      const callArgs = mockEvaluate.mock.calls[0][1]
+      expect(callArgs.rehypePlugins).toEqual(
+        expect.arrayContaining([
+          [expect.any(Function), { strategy: 'external-new-tab', siteUrl: 'https://example.com' }],
+        ])
+      )
+    })
   })
 
   describe('basePath image resolution', () => {

package/src/__tests__/seoUtils.test.ts

@@ -6,6 +6,7 @@ import {
   generateArticleMetadata,
   generateCategoryMetadata,
   getArticleSitemapEntries,
+  generateRssFeed,
 } from '../seoUtils'
 
 jest.mock('../server-articles', () => ({
@@ -579,3 +580,104 @@ describe('getArticleSitemapEntries', () => {
     expect(entries[0].lastModified).toEqual(new Date('2025-03-10'))
   })
 })
+
+describe('generateRssFeed', () => {
+  const baseConfig: ArticlesConfig = {
+    siteUrl: 'https://example.com',
+    siteName: 'Example Site',
+    description: 'Test description',
+  }
+
+  const baseArticle = {
+    slug: 'my-article',
+    title: 'My Article',
+    excerpt: 'A short excerpt',
+    date: '2024-01-15',
+    author: 'Jane Doe',
+    category: 'Tales of the Valiant',
+    categories: ['Tales of the Valiant'],
+    readTime: '3 min read',
+    featuredImage: '/articles/my-article/hero.jpg',
+    tags: [],
+  }
+
+  it('returns a string starting with the XML declaration', () => {
+    const xml = generateRssFeed([], baseConfig)
+    expect(xml).toContain('<?xml version="1.0" encoding="UTF-8" ?>')
+  })
+
+  it('includes xmlns:media namespace in the rss element', () => {
+    const xml = generateRssFeed([], baseConfig)
+    expect(xml).toContain('xmlns:media="http://search.yahoo.com/mrss/"')
+  })
+
+  it('renders <category> from article.category', () => {
+    const xml = generateRssFeed([baseArticle], baseConfig)
+    expect(xml).toContain('<category><![CDATA[Tales of the Valiant]]></category>')
+  })
+
+  it('renders <media:content> with resolved absolute image URL', () => {
+    const xml = generateRssFeed([baseArticle], baseConfig)
+    expect(xml).toContain(
+      '<media:content url="https://example.com/articles/my-article/hero.jpg" medium="image" width="1200" height="630"/>'
+    )
+  })
+
+  it('passes through absolute featuredImage URLs unchanged in <media:content>', () => {
+    const article = { ...baseArticle, featuredImage: 'https://cdn.example.com/image.jpg' }
+    const xml = generateRssFeed([article], baseConfig)
+    expect(xml).toContain(
+      '<media:content url="https://cdn.example.com/image.jpg" medium="image" width="1200" height="630"/>'
+    )
+  })
+
+  it('omits <category> when article.category is empty', () => {
+    const article = { ...baseArticle, category: '' }
+    const xml = generateRssFeed([article], baseConfig)
+    expect(xml).not.toContain('<category>')
+  })
+
+  it('omits <media:content> when article.featuredImage is empty', () => {
+    const article = { ...baseArticle, featuredImage: '' }
+    const xml = generateRssFeed([article], baseConfig)
+    expect(xml).not.toContain('<media:content')
+  })
+
+  it('strips trailing slash from siteUrl when resolving image URL', () => {
+    const article = { ...baseArticle }
+    const xml = generateRssFeed([article], { ...baseConfig, siteUrl: 'https://example.com/' })
+    expect(xml).not.toContain('//articles')
+    expect(xml).toContain('https://example.com/articles/my-article/hero.jpg')
+  })
+
+  it('renders <title>, <link>, <guid>, <pubDate>, <description>, and <author>', () => {
+    const xml = generateRssFeed([baseArticle], baseConfig)
+    expect(xml).toContain('<![CDATA[My Article]]>')
+    expect(xml).toContain('https://example.com/articles/my-article')
+    expect(xml).toContain('<pubDate>')
+    expect(xml).toContain('<![CDATA[A short excerpt]]>')
+    expect(xml).toContain('<author>Jane Doe</author>')
+  })
+
+  it('uses config.description in the channel description', () => {
+    const xml = generateRssFeed([], baseConfig)
+    expect(xml).toContain('<![CDATA[Test description]]>')
+  })
+
+  it('falls back to siteName articles when description is absent', () => {
+    const xml = generateRssFeed([], { siteUrl: 'https://example.com', siteName: 'My Site' })
+    expect(xml).toContain('<![CDATA[My Site articles]]>')
+  })
+
+  it('omits author when showAuthor is false', () => {
+    const xml = generateRssFeed([baseArticle], { ...baseConfig, showAuthor: false })
+    expect(xml).not.toContain('<author>')
+  })
+
+  it('renders multiple items', () => {
+    const second = { ...baseArticle, slug: 'second', title: 'Second Article' }
+    const xml = generateRssFeed([baseArticle, second], baseConfig)
+    expect(xml).toContain('<![CDATA[My Article]]>')
+    expect(xml).toContain('<![CDATA[Second Article]]>')
+  })
+})

package/src/__tests__/server-articles.test.ts

@@ -17,6 +17,7 @@ import {
   searchArticles,
 } from '../server-articles'
 import { setArticlesErrorHandler } from '../errorReporting'
+import { markdownToHtml } from '../markdown'
 
 jest.mock('react', () => ({ cache: (fn: Function) => fn }))
 jest.mock('node:fs')
@@ -27,6 +28,7 @@ jest.mock('../markdown', () => ({
 jest.mock('reading-time', () => () => ({ text: '2 min read' }))
 
 const mockedFs = fs as jest.Mocked<typeof fs>
+const mockedMarkdownToHtml = markdownToHtml as jest.MockedFunction<typeof markdownToHtml>
 const articlesDirectory = path.join(process.cwd(), 'public/articles')
 
 beforeEach(() => {
@@ -480,7 +482,13 @@ describe('getArticleMetadata - content handling', () => {
       },
     ])
 
-    const article = await getArticleMetadata('markdown-article')
+    const config = {
+      siteUrl: 'https://example.com',
+      siteName: 'Example',
+      linkTargetStrategy: 'external-new-tab' as const,
+    }
+
+    const article = await getArticleMetadata('markdown-article', config)
 
     expect(article).toEqual(
       expect.objectContaining({
@@ -493,6 +501,11 @@ describe('getArticleMetadata - content handling', () => {
         toc: [],
       })
     )
+    expect(mockedMarkdownToHtml).toHaveBeenCalledWith(
+      '\n## Heading\n\nMarkdown body',
+      'markdown-article',
+      config
+    )
   })
 
   it('loads mdx articles as source instead of rendered html', async () => {
@@ -515,6 +528,7 @@ describe('getArticleMetadata - content handling', () => {
       })
     )
     expect(article?.mdxSource?.trim()).toBe('<Component />')
+    expect(mockedMarkdownToHtml).not.toHaveBeenCalled()
   })
 
   it('returns null when article file loading fails', async () => {

package/src/articlesConfig.ts

@@ -67,6 +67,9 @@ export interface HeroConfig {
   description?: string
 }
 
+/** Controls how article body links set target/rel attributes. */
+export type LinkTargetStrategy = 'external-new-tab' | 'all-new-tab' | 'same-tab'
+
 /** Top-level configuration object. Pass one instance to every library component. */
 export interface ArticlesConfig {
   /** Canonical base URL of the site, used in metadata and JSON-LD. Example: `'https://yoursite.com'` */
@@ -102,6 +105,8 @@ export interface ArticlesConfig {
   showBackToArticles?: boolean
   /** Set to false to hide author names from UI and metadata. Default: true. */
   showAuthor?: boolean
+  /** Article body link target behavior. Default: `'external-new-tab'`. */
+  linkTargetStrategy?: LinkTargetStrategy
 }
 
 export const DEFAULT_PAGE_SIZE = 6

package/src/index.ts

@@ -42,6 +42,7 @@ export type {
   ArticlesSection,
   CategoryDescription,
   CommentsConfig,
+  LinkTargetStrategy,
 } from './articlesConfig'
 export { DEFAULT_LAYOUT, DEFAULT_PAGE_SIZE, DEFAULT_CATEGORIES_PAGE_SIZE } from './articlesConfig'
 export type { Article, CategoryInfo, FaqItem, HowToStep, TocItem } from './articleTypes'

package/src/markdown.ts

@@ -11,8 +11,67 @@ import remarkRehype from 'remark-rehype'
 import { Plugin } from 'unified'
 import { visit } from 'unist-util-visit'
 import type { TocItem } from './articleTypes'
+import type { ArticlesConfig, LinkTargetStrategy } from './articlesConfig'
 import { reportArticlesError } from './errorReporting'
 
+type LinkTargetOptions = Readonly<{
+  strategy?: LinkTargetStrategy
+  siteUrl?: string
+}>
+
+const DEFAULT_LINK_TARGET_STRATEGY: LinkTargetStrategy = 'external-new-tab'
+
+function isNonBrowserNavigationLink(href: string): boolean {
+  return (
+    /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href) &&
+    !href.startsWith('http://') &&
+    !href.startsWith('https://')
+  )
+}
+
+function getOrigin(url: string | undefined): string | null {
+  if (!url) return null
+  try {
+    return new URL(url).origin
+  } catch {
+    return null
+  }
+}
+
+function isExternalHttpLink(href: string, siteUrl?: string): boolean {
+  if (!href.startsWith('http://') && !href.startsWith('https://')) return false
+  const siteOrigin = getOrigin(siteUrl)
+  if (!siteOrigin) return true
+  return getOrigin(href) !== siteOrigin
+}
+
+function shouldOpenInNewTab(href: string, options: LinkTargetOptions = {}): boolean {
+  if (!href || href.startsWith('#') || isNonBrowserNavigationLink(href)) return false
+
+  const strategy = options.strategy ?? DEFAULT_LINK_TARGET_STRATEGY
+  if (strategy === 'same-tab') return false
+  if (strategy === 'all-new-tab') return true
+  return isExternalHttpLink(href, options.siteUrl)
+}
+
+function applyLinkTarget(props: Record<string, unknown>, options?: LinkTargetOptions): void {
+  const href = typeof props.href === 'string' ? props.href : ''
+  if (shouldOpenInNewTab(href, options)) {
+    props.target = '_blank'
+    props.rel = 'noopener noreferrer'
+    return
+  }
+  delete props.target
+  delete props.rel
+}
+
+function getLinkTargetOptions(config?: ArticlesConfig): LinkTargetOptions {
+  return {
+    strategy: config?.linkTargetStrategy,
+    siteUrl: config?.siteUrl,
+  }
+}
+
 // Import the sanitizeImagePath function
 function sanitizeImagePath(rawPath: string, articleSlug: string): string | null {
   if (!rawPath || typeof rawPath !== 'string') {
@@ -169,7 +228,7 @@ function processFootnotesSection(node: Element): void {
   if (node.properties) node.properties.className = undefined
 }
 
-export const customRenderer: Plugin<[], Root> = () => {
+export const customRenderer: Plugin<[LinkTargetOptions?], Root> = (linkTargetOptions = {}) => {
   return (tree: Root) => {
     // First pass: Apply general styles
     visit(tree, 'element', (node: Element) => {
@@ -194,11 +253,7 @@ export const customRenderer: Plugin<[], Root> = () => {
             break
           case 'a': {
             props.className = 'text-primary hover:underline transition-colors duration-200'
-            const href = typeof props.href === 'string' ? props.href : ''
-            if (!href.startsWith('#')) {
-              props.target = '_blank'
-              props.rel = 'noopener noreferrer'
-            }
+            applyLinkTarget(props, linkTargetOptions)
             break
           }
           case 'ul':
@@ -278,7 +333,11 @@ const rehypeProcessImages: Plugin<[{ articleSlug?: string }], Root> = (options =
   }
 }
 
-export async function markdownToHtml(markdown: string, articleSlug?: string) {
+export async function markdownToHtml(
+  markdown: string,
+  articleSlug?: string,
+  config?: ArticlesConfig
+) {
   try {
     // Start building the remark processor
     let processor = remark()
@@ -286,7 +345,7 @@ export async function markdownToHtml(markdown: string, articleSlug?: string) {
       .use(remarkGfm)
       .use(remarkGithubBlockquoteAlert)
       .use(remarkRehype)
-      .use(customRenderer)
+      .use(customRenderer, getLinkTargetOptions(config))
       .use(rehypeSlug)
       // @ts-ignore
       .use(rehypePrism)

package/src/renderMdx.tsx

@@ -13,6 +13,7 @@ import rehypeSlug from 'rehype-slug'
 import remarkGfm from 'remark-gfm'
 import remarkGithubBlockquoteAlert from 'remark-github-blockquote-alert'
 import { customRenderer } from './markdown'
+import type { ArticlesConfig } from './articlesConfig'
 
 type MdxContent = ComponentType<{
   components?: Record<string, ComponentType<unknown>>
@@ -26,7 +27,7 @@ function makeImgComponent(basePath: string) {
   }
 }
 
-export async function renderMdxSource(source: string, basePath?: string) {
+export async function renderMdxSource(source: string, basePath?: string, config?: ArticlesConfig) {
   const isDevelopment = process.env.NODE_ENV === 'development'
 
   const mdxModule = await evaluate(source, {
@@ -34,7 +35,7 @@ export async function renderMdxSource(source: string, basePath?: string) {
     development: isDevelopment,
     remarkPlugins: [remarkGfm, remarkGithubBlockquoteAlert],
     rehypePlugins: [
-      customRenderer,
+      [customRenderer, { strategy: config?.linkTargetStrategy, siteUrl: config?.siteUrl }],
       rehypeSlug,
       // @ts-ignore
       rehypePrism,

package/src/seoUtils.ts

@@ -8,6 +8,60 @@ import {
   getAvailableArticleSlugs,
 } from './server-articles'
 import { ArticlesConfig } from './articlesConfig'
+import type { Article } from './articleTypes'
+
+function escapeXml(str: string): string {
+  return str
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;')
+}
+
+export function generateRssFeed(articles: Article[], config: ArticlesConfig): string {
+  const siteUrl = config.siteUrl.replace(/\/$/, '')
+  const showAuthor = config.showAuthor !== false
+
+  const items = articles
+    .map((article) => {
+      const url = `${siteUrl}/articles/${article.slug}`
+      const pubDate = article.date ? new Date(article.date).toUTCString() : ''
+      const imageUrl = article.featuredImage ? resolveImageUrl(article.featuredImage, siteUrl) : ''
+
+      return [
+        '    <item>',
+        `      <title><![CDATA[${article.title}]]></title>`,
+        `      <link>${url}</link>`,
+        `      <guid isPermaLink="true">${url}</guid>`,
+        pubDate ? `      <pubDate>${pubDate}</pubDate>` : '',
+        article.excerpt ? `      <description><![CDATA[${article.excerpt}]]></description>` : '',
+        showAuthor && article.author ? `      <author>${escapeXml(article.author)}</author>` : '',
+        article.category ? `      <category><![CDATA[${article.category}]]></category>` : '',
+        imageUrl
+          ? `      <media:content url="${imageUrl}" medium="image" width="1200" height="630"/>`
+          : '',
+        '    </item>',
+      ]
+        .filter(Boolean)
+        .join('\n')
+    })
+    .join('\n')
+
+  const description = config.description ?? `${config.siteName} articles`
+
+  return `<?xml version="1.0" encoding="UTF-8" ?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="http://search.yahoo.com/mrss/">
+  <channel>
+    <title><![CDATA[${config.siteName}]]></title>
+    <link>${siteUrl}/articles</link>
+    <description><![CDATA[${description}]]></description>
+    <language>en</language>
+    <atom:link href="${siteUrl}/articles/feed.xml" rel="self" type="application/rss+xml" />
+${items}
+  </channel>
+</rss>`
+}
 
 export function generateArticleStaticParams(): { slug: string }[] {
   return getAvailableArticleSlugs().map((slug) => ({ slug }))

package/src/server-articles.ts

@@ -197,33 +197,35 @@ async function getArticleSummary(slug: string): Promise<Article | null> {
   }
 }
 
-export const getArticleMetadata = cache(async (slug: string): Promise<Article | null> => {
-  try {
-    const summary = await getArticleSummary(slug)
-    if (!summary) return null
-    const found = findArticleFile(slug)
-    if (!found) return null
-    const fileContent = fs.readFileSync(found.filePath, 'utf8')
-    const { content: markdownContent } = matter(fileContent)
-    const toc = await extractToc(markdownContent)
-    let htmlContent: string | undefined
-    let mdxSource: string | undefined
-    if (found.contentType === 'mdx') {
-      mdxSource = markdownContent
-    } else {
-      htmlContent = await markdownToHtml(markdownContent, slug)
+export const getArticleMetadata = cache(
+  async (slug: string, config?: ArticlesConfig): Promise<Article | null> => {
+    try {
+      const summary = await getArticleSummary(slug)
+      if (!summary) return null
+      const found = findArticleFile(slug)
+      if (!found) return null
+      const fileContent = fs.readFileSync(found.filePath, 'utf8')
+      const { content: markdownContent } = matter(fileContent)
+      const toc = await extractToc(markdownContent)
+      let htmlContent: string | undefined
+      let mdxSource: string | undefined
+      if (found.contentType === 'mdx') {
+        mdxSource = markdownContent
+      } else {
+        htmlContent = await markdownToHtml(markdownContent, slug, config)
+      }
+      return { ...summary, content: markdownContent, htmlContent, mdxSource, toc }
+    } catch (error) {
+      reportArticlesError({
+        code: 'article-load-failed',
+        message: 'Unable to load article metadata.',
+        error,
+        context: { slug },
+      })
+      return null
     }
-    return { ...summary, content: markdownContent, htmlContent, mdxSource, toc }
-  } catch (error) {
-    reportArticlesError({
-      code: 'article-load-failed',
-      message: 'Unable to load article metadata.',
-      error,
-      context: { slug },
-    })
-    return null
   }
-})
+)
 
 export const getAllArticles = cache(async (): Promise<Article[]> => {
   const slugs = getAvailableArticleSlugs()

package/src/server.ts

@@ -17,6 +17,7 @@ export {
 } from './server-articles'
 
 export {
+  generateRssFeed,
   generateArticleStaticParams,
   generateCategoryStaticParams,
   generateArticlesIndexMetadata,
@@ -31,7 +32,7 @@ export { ArticleContent } from './ArticleContent'
 export { ArticleTOC } from './ArticleTOC'
 
 export type { Article, CategoryInfo, TocItem } from './articleTypes'
-export type { ArticlesConfig } from './articlesConfig'
+export type { ArticlesConfig, LinkTargetStrategy } from './articlesConfig'
 export type {
   ArticlesErrorCode,
   ArticlesErrorContext,