@next-md-blog/core 1.0.0

package/dist/core/constants.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Default directory name for blog posts
+ */
+export declare const POSTS_DIR_NAME = "posts";
+/**
+ * Markdown file extension
+ */
+export declare const MARKDOWN_EXTENSION = ".md";
+/**
+ * MDX file extension
+ */
+export declare const MDX_EXTENSION = ".mdx";
+/**
+ * Array of supported file extensions
+ */
+export declare const SUPPORTED_EXTENSIONS: string[];
+/**
+ * Regular expression to match markdown and MDX files
+ */
+export declare const MARKDOWN_FILE_REGEX: RegExp;
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_SITE_NAME = "My Blog";
+export declare const DEFAULT_BLOG_ROUTE = "blog";
+export declare const DEFAULT_BLOGS_ROUTE = "blogs";
+export declare const DEFAULT_LANG = "en";
+export declare const RSS_POST_LIMIT = 20;
+/**
+ * Gets the posts directory path relative to the current working directory
+ * @param customPath - Optional custom path to posts directory
+ * @param locale - Optional locale code. If provided, appends /{locale} to the posts directory path
+ * @returns The full path to the posts directory
+ */
+export declare function getPostsDirectory(customPath?: string, locale?: string): string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC;;GAEG;AACH,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,aAAa,SAAS,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,oBAAoB,UAAsC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAAgB,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAC3C,eAAO,MAAM,kBAAkB,SAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,UAAU,CAAC;AAC3C,eAAO,MAAM,YAAY,OAAO,CAAC;AACjC,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAU9E"}

package/dist/core/constants.js

@@ -0,0 +1,44 @@
+import path from 'path';
+/**
+ * Default directory name for blog posts
+ */
+export const POSTS_DIR_NAME = 'posts';
+/**
+ * Markdown file extension
+ */
+export const MARKDOWN_EXTENSION = '.md';
+/**
+ * MDX file extension
+ */
+export const MDX_EXTENSION = '.mdx';
+/**
+ * Array of supported file extensions
+ */
+export const SUPPORTED_EXTENSIONS = [MARKDOWN_EXTENSION, MDX_EXTENSION];
+/**
+ * Regular expression to match markdown and MDX files
+ */
+export const MARKDOWN_FILE_REGEX = /\.(md|mdx)$/;
+/**
+ * Default configuration values
+ */
+export const DEFAULT_SITE_NAME = 'My Blog';
+export const DEFAULT_BLOG_ROUTE = 'blog';
+export const DEFAULT_BLOGS_ROUTE = 'blogs';
+export const DEFAULT_LANG = 'en';
+export const RSS_POST_LIMIT = 20;
+/**
+ * Gets the posts directory path relative to the current working directory
+ * @param customPath - Optional custom path to posts directory
+ * @param locale - Optional locale code. If provided, appends /{locale} to the posts directory path
+ * @returns The full path to the posts directory
+ */
+export function getPostsDirectory(customPath, locale) {
+    const baseDir = customPath || POSTS_DIR_NAME;
+    const postsDir = path.join(process.cwd(), baseDir);
+    // If locale is provided, append it to the path (e.g., posts/en/)
+    if (locale) {
+        return path.join(postsDir, locale);
+    }
+    return postsDir;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Base error class for next-md-blog library errors
+ */
+export declare class MdxBlogError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * Error thrown when a blog post is not found
+ */
+export declare class BlogPostNotFoundError extends MdxBlogError {
+    constructor(slug: string);
+}
+/**
+ * Error thrown when there's an issue reading files
+ */
+export declare class FileReadError extends MdxBlogError {
+    constructor(filePath: string, originalError?: Error, context?: {
+        operation?: string;
+        slug?: string;
+    });
+    /** The file path that failed to be read */
+    readonly filePath: string;
+    /** The original error that occurred */
+    readonly originalError?: Error;
+    /** Additional context about the operation */
+    readonly context?: {
+        operation?: string;
+        slug?: string;
+    };
+}
+/**
+ * Error thrown when there's an issue with directory operations
+ */
+export declare class DirectoryError extends MdxBlogError {
+    constructor(directoryPath: string, originalError?: Error, context?: {
+        operation?: string;
+    });
+    /** The directory path that failed */
+    readonly directoryPath: string;
+    /** The original error that occurred */
+    readonly originalError?: Error;
+    /** Additional context about the operation */
+    readonly context?: {
+        operation?: string;
+    };
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;aACQ,IAAI,EAAE,MAAM;gBAA7C,OAAO,EAAE,MAAM,EAAkB,IAAI,EAAE,MAAM;CAK1D;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,IAAI,EAAE,MAAM;CAKzB;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,YAAY;gBAE3C,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,KAAK,EACrB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAkBjD,2CAA2C;IAC3C,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,uCAAuC;IACvC,SAAgB,aAAa,CAAC,EAAE,KAAK,CAAC;IACtC,6CAA6C;IAC7C,SAAgB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACjE;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,YAAY;gBAE5C,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,KAAK,EACrB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAkBlC,qCAAqC;IACrC,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,uCAAuC;IACvC,SAAgB,aAAa,CAAC,EAAE,KAAK,CAAC;IACtC,6CAA6C;IAC7C,SAAgB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAClD"}

package/dist/core/errors.js

@@ -0,0 +1,57 @@
+/**
+ * Base error class for next-md-blog library errors
+ */
+export class MdxBlogError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'MdxBlogError';
+        Object.setPrototypeOf(this, MdxBlogError.prototype);
+    }
+}
+/**
+ * Error thrown when a blog post is not found
+ */
+export class BlogPostNotFoundError extends MdxBlogError {
+    constructor(slug) {
+        super(`Blog post with slug "${slug}" not found`, 'BLOG_POST_NOT_FOUND');
+        this.name = 'BlogPostNotFoundError';
+        Object.setPrototypeOf(this, BlogPostNotFoundError.prototype);
+    }
+}
+/**
+ * Error thrown when there's an issue reading files
+ */
+export class FileReadError extends MdxBlogError {
+    constructor(filePath, originalError, context) {
+        const contextMessage = context?.operation ? ` during ${context.operation}` : '';
+        super(`Failed to read file at "${filePath}"${contextMessage}: ${originalError?.message || 'Unknown error'}`, 'FILE_READ_ERROR');
+        this.name = 'FileReadError';
+        this.filePath = filePath;
+        if (originalError !== undefined) {
+            this.originalError = originalError;
+        }
+        if (context !== undefined) {
+            this.context = context;
+        }
+        Object.setPrototypeOf(this, FileReadError.prototype);
+    }
+}
+/**
+ * Error thrown when there's an issue with directory operations
+ */
+export class DirectoryError extends MdxBlogError {
+    constructor(directoryPath, originalError, context) {
+        const contextMessage = context?.operation ? ` during ${context.operation}` : '';
+        super(`Directory operation failed for "${directoryPath}"${contextMessage}: ${originalError?.message || 'Unknown error'}`, 'DIRECTORY_ERROR');
+        this.name = 'DirectoryError';
+        this.directoryPath = directoryPath;
+        if (originalError !== undefined) {
+            this.originalError = originalError;
+        }
+        if (context !== undefined) {
+            this.context = context;
+        }
+        Object.setPrototypeOf(this, DirectoryError.prototype);
+    }
+}

package/dist/core/file-utils.d.ts

@@ -0,0 +1,22 @@
+import type { BlogPost, BlogPostMetadata, GetBlogPostOptions } from './types.js';
+/**
+ * Gets a single blog post by slug
+ * @param slug - The slug of the blog post (filename without .md or .mdx extension)
+ * @param options - Optional configuration
+ * @returns The blog post or null if not found
+ * @throws {Error} If slug is invalid or file cannot be read
+ */
+export declare function getBlogPost(slug: string, options?: GetBlogPostOptions): Promise<BlogPost | null>;
+/**
+ * Gets all blog posts from the posts directory
+ * @param options - Optional configuration
+ * @returns Array of blog post metadata, sorted by date (newest first)
+ */
+export declare function getAllBlogPosts(options?: GetBlogPostOptions): Promise<BlogPostMetadata[]>;
+/**
+ * Gets all blog post slugs
+ * @param options - Optional configuration
+ * @returns Array of slug strings
+ */
+export declare function getAllBlogPostSlugs(options?: GetBlogPostOptions): Promise<string[]>;
+//# sourceMappingURL=file-utils.d.ts.map

package/dist/core/file-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../src/core/file-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,kBAAkB,EAAU,MAAM,YAAY,CAAC;AAkHzF;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAuB1B;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0D7B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,MAAM,EAAE,CAAC,CAEnB"}

package/dist/core/file-utils.js

@@ -0,0 +1,180 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { getPostsDirectory, SUPPORTED_EXTENSIONS, MARKDOWN_FILE_REGEX } from './constants.js';
+import { validateSlug, validateFrontmatter, validateContent } from './validation.js';
+import { BlogPostNotFoundError, FileReadError, DirectoryError } from './errors.js';
+import { calculateReadingTime, calculateWordCount, normalizeAuthors } from './utils.js';
+import { getConfig } from './config.js';
+/**
+ * Safely reads a file and returns its contents
+ * @param filePath - Path to the file
+ * @returns File contents or null if file doesn't exist
+ * @throws {FileReadError} If file exists but cannot be read
+ */
+function readFileSafe(filePath) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile()) {
+            return null;
+        }
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    catch (error) {
+        throw new FileReadError(filePath, error instanceof Error ? error : undefined, { operation: 'readFileSafe' });
+    }
+}
+/**
+ * Safely reads directory contents
+ * @param dirPath - Path to the directory
+ * @returns Array of filenames or empty array if directory doesn't exist
+ * @throws {DirectoryError} If directory exists but cannot be read
+ */
+function readDirectorySafe(dirPath) {
+    try {
+        if (!fs.existsSync(dirPath)) {
+            return [];
+        }
+        const stats = fs.statSync(dirPath);
+        if (!stats.isDirectory()) {
+            return [];
+        }
+        return fs.readdirSync(dirPath);
+    }
+    catch (error) {
+        throw new DirectoryError(dirPath, error instanceof Error ? error : undefined, { operation: 'readDirectorySafe' });
+    }
+}
+/**
+ * Parses a markdown or MDX file and extracts frontmatter and content
+ * @param filePath - Path to the markdown or MDX file
+ * @param slug - The slug for the post
+ * @param config - Optional blog configuration for author resolution
+ * @returns Parsed blog post
+ * @throws {FileReadError} If file cannot be read or parsed
+ */
+function parseMarkdownFile(filePath, slug, config) {
+    const fileContents = readFileSafe(filePath);
+    if (fileContents === null) {
+        throw new BlogPostNotFoundError(slug);
+    }
+    try {
+        const { data: frontmatter, content } = matter(fileContents);
+        validateContent(content);
+        const trimmedContent = content.trim();
+        const validatedFrontmatter = validateFrontmatter(frontmatter);
+        // Automatically calculate reading time and word count
+        // Use frontmatter value if provided, otherwise calculate
+        const readingTime = validatedFrontmatter.readingTime || calculateReadingTime(trimmedContent);
+        const wordCount = calculateWordCount(trimmedContent);
+        // Use provided config or fallback to defaults
+        const blogConfig = config || getConfig();
+        // Normalize authors (resolve from config if available)
+        const authors = normalizeAuthors(validatedFrontmatter.author, validatedFrontmatter.authors, blogConfig.authors);
+        return {
+            slug,
+            content: trimmedContent,
+            frontmatter: validatedFrontmatter,
+            readingTime,
+            wordCount,
+            authors,
+        };
+    }
+    catch (error) {
+        throw new FileReadError(filePath, error instanceof Error ? error : new Error('Failed to parse markdown'), { operation: 'parseMarkdownFile', slug });
+    }
+}
+/**
+ * Gets a single blog post by slug
+ * @param slug - The slug of the blog post (filename without .md or .mdx extension)
+ * @param options - Optional configuration
+ * @returns The blog post or null if not found
+ * @throws {Error} If slug is invalid or file cannot be read
+ */
+export async function getBlogPost(slug, options = {}) {
+    try {
+        validateSlug(slug);
+        const postsDir = getPostsDirectory(options.postsDir, options.locale);
+        // Try both .md and .mdx extensions
+        for (const ext of SUPPORTED_EXTENSIONS) {
+            const filePath = path.join(postsDir, `${slug}${ext}`);
+            const fileContents = readFileSafe(filePath);
+            if (fileContents !== null) {
+                return parseMarkdownFile(filePath, slug, options.config);
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        if (error instanceof BlogPostNotFoundError || error instanceof FileReadError) {
+            throw error;
+        }
+        // Re-throw validation errors
+        throw error;
+    }
+}
+/**
+ * Gets all blog posts from the posts directory
+ * @param options - Optional configuration
+ * @returns Array of blog post metadata, sorted by date (newest first)
+ */
+export async function getAllBlogPosts(options = {}) {
+    try {
+        const postsDir = getPostsDirectory(options.postsDir, options.locale);
+        const files = readDirectorySafe(postsDir);
+        const mdFiles = files.filter((file) => MARKDOWN_FILE_REGEX.test(file));
+        const blogConfig = options.config || getConfig();
+        const posts = mdFiles
+            .map((file) => {
+            try {
+                // Remove both .md and .mdx extensions
+                const slug = file.replace(MARKDOWN_FILE_REGEX, '');
+                const filePath = path.join(postsDir, file);
+                const fileContents = readFileSafe(filePath);
+                if (fileContents === null) {
+                    return null;
+                }
+                const { data: frontmatter } = matter(fileContents);
+                const validatedFrontmatter = validateFrontmatter(frontmatter);
+                const authors = normalizeAuthors(validatedFrontmatter.author, validatedFrontmatter.authors, blogConfig.authors);
+                return {
+                    slug,
+                    frontmatter: validatedFrontmatter,
+                    authors,
+                };
+            }
+            catch (error) {
+                // Skip files that cannot be parsed
+                // In production, consider logging to a structured logger instead of console.warn
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                console.warn(`Skipping file ${file}: ${errorMessage}`);
+                return null;
+            }
+        })
+            .filter((post) => post !== null)
+            .sort((a, b) => {
+            const dateA = a.frontmatter?.date || '';
+            const dateB = b.frontmatter?.date || '';
+            return dateB.localeCompare(dateA);
+        });
+        return posts;
+    }
+    catch (error) {
+        // If directory doesn't exist, return empty array
+        if (error instanceof DirectoryError) {
+            return [];
+        }
+        throw error;
+    }
+}
+/**
+ * Gets all blog post slugs
+ * @param options - Optional configuration
+ * @returns Array of slug strings
+ */
+export function getAllBlogPostSlugs(options = {}) {
+    return getAllBlogPosts(options).then((posts) => posts.map((post) => post.slug));
+}

package/dist/core/seo-feeds.d.ts

@@ -0,0 +1,16 @@
+import type { BlogPost, BlogPostMetadata, Config } from './types.js';
+/**
+ * Generates sitemap XML for blog posts
+ * @param posts - Array of blog post metadata
+ * @param config - SEO configuration
+ * @returns Sitemap XML string
+ */
+export declare function generateSitemap(posts: BlogPostMetadata[], config?: Config): string;
+/**
+ * Generates RSS feed XML for blog posts
+ * @param posts - Array of blog posts
+ * @param config - SEO configuration
+ * @returns RSS XML string
+ */
+export declare function generateRSSFeed(posts: BlogPost[], config?: Config): string;
+//# sourceMappingURL=seo-feeds.d.ts.map

package/dist/core/seo-feeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seo-feeds.d.ts","sourceRoot":"","sources":["../../src/core/seo-feeds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAMrE;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,gBAAgB,EAAE,EACzB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAwBR;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAuDR"}

package/dist/core/seo-feeds.js

@@ -0,0 +1,73 @@
+import { getConfig } from './config.js';
+import { resolveFrontmatterField } from './type-guards.js';
+import { DEFAULT_SITE_NAME, RSS_POST_LIMIT } from './constants.js';
+import { resolvePostUrl, escapeXml, getAuthorName } from './seo-utils.js';
+/**
+ * Generates sitemap XML for blog posts
+ * @param posts - Array of blog post metadata
+ * @param config - SEO configuration
+ * @returns Sitemap XML string
+ */
+export function generateSitemap(posts, config) {
+    const blogConfig = config || getConfig();
+    const { siteUrl = '' } = blogConfig;
+    const urls = posts
+        .map((post) => {
+        const lastmod = resolveFrontmatterField(['modifiedDate', 'date'], post.frontmatter) || new Date().toISOString().split('T')[0];
+        const url = `${siteUrl}/blog/${post.slug}`;
+        return `  <url>
+    <loc>${escapeXml(url)}</loc>
+    <lastmod>${lastmod}</lastmod>
+    <changefreq>monthly</changefreq>
+    <priority>0.8</priority>
+  </url>`;
+    })
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}
+</urlset>`;
+}
+/**
+ * Generates RSS feed XML for blog posts
+ * @param posts - Array of blog posts
+ * @param config - SEO configuration
+ * @returns RSS XML string
+ */
+export function generateRSSFeed(posts, config) {
+    const blogConfig = config || getConfig();
+    const { siteName = DEFAULT_SITE_NAME, siteUrl = '', defaultAuthor, } = blogConfig;
+    const items = posts
+        .slice(0, RSS_POST_LIMIT) // Limit to most recent posts
+        .map((post) => {
+        const title = resolveFrontmatterField(['title'], post.frontmatter, post.slug) || post.slug;
+        const description = resolveFrontmatterField(['description', 'excerpt'], post.frontmatter, '') || '';
+        const authorObj = post.authors[0];
+        const author = authorObj ? getAuthorName(authorObj) : (defaultAuthor || '');
+        const pubDate = resolveFrontmatterField(['publishedDate', 'date'], post.frontmatter) || new Date().toISOString();
+        const url = resolvePostUrl(resolveFrontmatterField(['canonicalUrl'], post.frontmatter), post.slug, siteUrl);
+        // Format date for RSS (RFC 822)
+        const rssDate = new Date(pubDate).toUTCString();
+        return `    <item>
+      <title>${escapeXml(title)}</title>
+      <link>${escapeXml(url)}</link>
+      <guid isPermaLink="true">${escapeXml(url)}</guid>
+      <description>${escapeXml(description)}</description>
+      <author>${escapeXml(author)}</author>
+      <pubDate>${rssDate}</pubDate>
+    </item>`;
+    })
+        .join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(siteName)}</title>
+    <link>${escapeXml(siteUrl)}</link>
+    <description>Latest blog posts from ${escapeXml(siteName)}</description>
+    <language>en</language>
+    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
+    <atom:link href="${escapeXml(siteUrl)}/feed.xml" rel="self" type="application/rss+xml"/>
+${items}
+  </channel>
+</rss>`;
+}

package/dist/core/seo-metadata.d.ts

@@ -0,0 +1,17 @@
+import type { BlogPost, BlogPostMetadata, Config } from './types.js';
+import type { Metadata } from 'next';
+/**
+ * Generates comprehensive metadata for a blog post
+ * @param post - The blog post
+ * @param config - SEO configuration
+ * @returns Metadata object for Next.js
+ */
+export declare function generateBlogPostMetadata(post: BlogPost, config?: Config): Metadata;
+/**
+ * Generates metadata for the blog listing page
+ * @param posts - Array of blog posts
+ * @param config - SEO configuration
+ * @returns Metadata object for Next.js
+ */
+export declare function generateBlogListMetadata(posts: BlogPostMetadata[], config?: Config): Metadata;
+//# sourceMappingURL=seo-metadata.d.ts.map

package/dist/core/seo-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seo-metadata.d.ts","sourceRoot":"","sources":["../../src/core/seo-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAcrC;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,MAAM,CAAC,EAAE,MAAM,GACd,QAAQ,CAmMV;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,gBAAgB,EAAE,EACzB,MAAM,CAAC,EAAE,MAAM,GACd,QAAQ,CAwBV"}