@fullstackdatasolutions/articles 0.8.1 → 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__/nextjs-middleware.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Unit tests for nextjs-middleware.ts (Edge-safe URL rewrite helper).
+ * Uses manual mocks for next/server to avoid Edge runtime dependencies.
+ */
+
+// Manual mock for next/server - must be before imports
+const mockRewrite = jest.fn()
+
+jest.mock('next/server', () => ({
+  NextResponse: {
+    rewrite: (url: URL) => mockRewrite(url),
+  },
+}))
+
+import {
+  rewriteArticleMarkdown,
+  middleware,
+  config,
+  createArticleMarkdownMiddleware,
+} from '../nextjs-middleware'
+
+type MiddlewareRequest = Parameters<typeof rewriteArticleMarkdown>[0]
+
+function makeRequest(pathname: string, base = 'https://example.com'): MiddlewareRequest {
+  const request = {
+    nextUrl: { pathname },
+    url: `${base}${pathname}`,
+  }
+
+  return request as MiddlewareRequest
+}
+
+describe('rewriteArticleMarkdown', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockRewrite.mockImplementation((url: URL) => ({ type: 'rewrite', url }))
+  })
+
+  it('rewrites /articles/slug.md to /api/articles-markdown/slug.md', () => {
+    const req = makeRequest('/articles/some-article.md')
+    const result = rewriteArticleMarkdown(req)
+
+    expect(mockRewrite).toHaveBeenCalledTimes(1)
+    const calledUrl: URL = mockRewrite.mock.calls[0][0]
+    expect(calledUrl.pathname).toBe('/api/articles-markdown/some-article.md')
+    expect(result).toBeDefined()
+  })
+
+  it('rewrites nested slug path correctly', () => {
+    const req = makeRequest('/articles/category/nested-article.md')
+    rewriteArticleMarkdown(req)
+
+    const calledUrl: URL = mockRewrite.mock.calls[0][0]
+    expect(calledUrl.pathname).toBe('/api/articles-markdown/category/nested-article.md')
+  })
+
+  it('returns undefined for paths that do not start with /articles/', () => {
+    const req = makeRequest('/blog/some-article.md')
+    const result = rewriteArticleMarkdown(req)
+
+    expect(mockRewrite).not.toHaveBeenCalled()
+    expect(result).toBeUndefined()
+  })
+
+  it('returns undefined for paths that start with /articles/ but do not end with .md', () => {
+    const req = makeRequest('/articles/some-article')
+    const result = rewriteArticleMarkdown(req)
+
+    expect(mockRewrite).not.toHaveBeenCalled()
+    expect(result).toBeUndefined()
+  })
+
+  it('returns undefined for paths that end in .md but do not start with /articles/', () => {
+    const req = makeRequest('/docs/readme.md')
+    const result = rewriteArticleMarkdown(req)
+
+    expect(mockRewrite).not.toHaveBeenCalled()
+    expect(result).toBeUndefined()
+  })
+
+  it('returns undefined for the root path', () => {
+    const req = makeRequest('/')
+    const result = rewriteArticleMarkdown(req)
+
+    expect(mockRewrite).not.toHaveBeenCalled()
+    expect(result).toBeUndefined()
+  })
+
+  it('uses custom apiBase when provided', () => {
+    const req = makeRequest('/articles/my-article.md')
+    rewriteArticleMarkdown(req, '/custom/api/base')
+
+    const calledUrl: URL = mockRewrite.mock.calls[0][0]
+    expect(calledUrl.pathname).toBe('/custom/api/base/my-article.md')
+  })
+
+  it('defaults to /api/articles-markdown when apiBase is omitted', () => {
+    const req = makeRequest('/articles/test.md')
+    rewriteArticleMarkdown(req)
+
+    const calledUrl: URL = mockRewrite.mock.calls[0][0]
+    expect(calledUrl.pathname).toBe('/api/articles-markdown/test.md')
+  })
+})
+
+describe('middleware (legacy export)', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockRewrite.mockImplementation((url: URL) => ({ type: 'rewrite', url }))
+  })
+
+  it('is a function', () => {
+    expect(typeof middleware).toBe('function')
+  })
+
+  it('rewrites .md article paths', () => {
+    const req = makeRequest('/articles/legacy.md')
+    const result = middleware(req)
+
+    expect(mockRewrite).toHaveBeenCalledTimes(1)
+    expect(result).toBeDefined()
+  })
+
+  it('returns undefined for non-article paths', () => {
+    const req = makeRequest('/about')
+    const result = middleware(req)
+
+    expect(mockRewrite).not.toHaveBeenCalled()
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('config export', () => {
+  it('exports a matcher for article .md paths', () => {
+    expect(config).toEqual({
+      matcher: '/articles/:path*.md',
+    })
+  })
+})
+
+describe('createArticleMarkdownMiddleware', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockRewrite.mockImplementation((url: URL) => ({ type: 'rewrite', url }))
+  })
+
+  it('returns an object with middleware and config', () => {
+    const result = createArticleMarkdownMiddleware()
+    expect(typeof result.middleware).toBe('function')
+    expect(result.config).toEqual({ matcher: '/articles/:path*.md' })
+  })
+
+  it('middleware uses the default apiBase when none provided', () => {
+    const { middleware: mw } = createArticleMarkdownMiddleware()
+    const req = makeRequest('/articles/test.md')
+    mw(req)
+
+    const calledUrl: URL = mockRewrite.mock.calls[0][0]
+    expect(calledUrl.pathname).toBe('/api/articles-markdown/test.md')
+  })
+
+  it('middleware uses the custom apiBase when provided', () => {
+    const { middleware: mw } = createArticleMarkdownMiddleware('/v2/articles-api')
+    const req = makeRequest('/articles/test.md')
+    mw(req)
+
+    const calledUrl: URL = mockRewrite.mock.calls[0][0]
+    expect(calledUrl.pathname).toBe('/v2/articles-api/test.md')
+  })
+
+  it('middleware returns undefined for non-matching paths', () => {
+    const { middleware: mw } = createArticleMarkdownMiddleware()
+    const req = makeRequest('/about')
+    const result = mw(req)
+
+    expect(result).toBeUndefined()
+  })
+
+  it('config always contains the standard matcher regardless of apiBase', () => {
+    const { config: cfg } = createArticleMarkdownMiddleware('/custom')
+    expect(cfg).toEqual({ matcher: '/articles/:path*.md' })
+  })
+})

package/src/__tests__/nextjs.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Unit tests for nextjs.ts (createArticleMarkdownHandler factory).
+ * Mocks server-articles to isolate the handler logic.
+ */
+
+const mockGetArticleMarkdownResponse = jest.fn()
+
+jest.mock('../server-articles', () => ({
+  getArticleMarkdownResponse: (...args: unknown[]) => mockGetArticleMarkdownResponse(...args),
+}))
+
+import { createArticleMarkdownHandler } from '../nextjs'
+import type { ArticlesConfig } from '../articlesConfig'
+import type { NextRequest } from 'next/server'
+
+// jsdom does not include Response - polyfill to match server-articles.test.ts pattern
+class TestResponse {
+  readonly status: number
+  constructor(
+    private readonly body: string,
+    init?: { status?: number }
+  ) {
+    this.status = init?.status ?? 200
+  }
+  text(): Promise<string> {
+    return Promise.resolve(this.body)
+  }
+}
+
+if (globalThis.Response === undefined) {
+  Object.defineProperty(globalThis, 'Response', {
+    value: TestResponse,
+    configurable: true,
+  })
+}
+
+const siteConfig: ArticlesConfig = {
+  siteUrl: 'https://example.com',
+  siteName: 'Example Site',
+}
+
+function makeContext(slugValue: string | string[]): {
+  params: Promise<Record<string, string | string[]>>
+} {
+  return {
+    params: Promise.resolve({ slug: slugValue }),
+  }
+}
+
+function makeRequest(): NextRequest {
+  return {} as NextRequest
+}
+
+describe('createArticleMarkdownHandler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockGetArticleMarkdownResponse.mockResolvedValue(new Response('# Article', { status: 200 }))
+  })
+
+  it('returns an object with a GET handler', () => {
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    expect(typeof GET).toBe('function')
+  })
+
+  it('calls getArticleMarkdownResponse with joined slug array and config', async () => {
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    const ctx = makeContext(['category', 'my-article.md'])
+    await GET(makeRequest(), ctx)
+
+    expect(mockGetArticleMarkdownResponse).toHaveBeenCalledWith('category/my-article', siteConfig)
+  })
+
+  it('strips trailing .md from a slug array', async () => {
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    const ctx = makeContext(['some-article.md'])
+    await GET(makeRequest(), ctx)
+
+    expect(mockGetArticleMarkdownResponse).toHaveBeenCalledWith('some-article', siteConfig)
+  })
+
+  it('handles a plain string slug without .md extension', async () => {
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    const ctx = makeContext('plain-slug')
+    await GET(makeRequest(), ctx)
+
+    expect(mockGetArticleMarkdownResponse).toHaveBeenCalledWith('plain-slug', siteConfig)
+  })
+
+  it('handles a plain string slug with .md extension - strips it', async () => {
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    const ctx = makeContext('plain-slug.md')
+    await GET(makeRequest(), ctx)
+
+    expect(mockGetArticleMarkdownResponse).toHaveBeenCalledWith('plain-slug', siteConfig)
+  })
+
+  it('handles undefined slug (missing param) as empty string', async () => {
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    const ctx = {
+      params: Promise.resolve({} as Record<string, string | string[]>),
+    }
+    await GET(makeRequest(), ctx)
+
+    expect(mockGetArticleMarkdownResponse).toHaveBeenCalledWith('', siteConfig)
+  })
+
+  it('returns the response from getArticleMarkdownResponse', async () => {
+    const mockResponse = new Response('markdown content', { status: 200 })
+    mockGetArticleMarkdownResponse.mockResolvedValue(mockResponse)
+
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    const ctx = makeContext(['article.md'])
+    const result = await GET(makeRequest(), ctx)
+
+    expect(result).toBe(mockResponse)
+  })
+
+  it('passes the config object through to getArticleMarkdownResponse', async () => {
+    const customConfig: ArticlesConfig = {
+      siteUrl: 'https://custom.example.com',
+      siteName: 'Custom Site',
+    }
+    const { GET } = createArticleMarkdownHandler(customConfig)
+    const ctx = makeContext(['test.md'])
+    await GET(makeRequest(), ctx)
+
+    expect(mockGetArticleMarkdownResponse).toHaveBeenCalledWith('test', customConfig)
+  })
+
+  it('handles deeply nested slug array', async () => {
+    const { GET } = createArticleMarkdownHandler(siteConfig)
+    const ctx = makeContext(['a', 'b', 'c', 'deep-article.md'])
+    await GET(makeRequest(), ctx)
+
+    expect(mockGetArticleMarkdownResponse).toHaveBeenCalledWith('a/b/c/deep-article', siteConfig)
+  })
+})

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'