@next-md-blog/core 1.0.0

package/dist/core/seo-metadata.js

@@ -0,0 +1,197 @@
+import { calculateReadingTime, calculateWordCount } from './utils.js';
+import { getConfig } from './config.js';
+import { resolveFrontmatterField, isStringArray } from './type-guards.js';
+import { DEFAULT_SITE_NAME, DEFAULT_LANG } from './constants.js';
+import { normalizeKeywords, getAuthorNames, ensureAuthorsResolved, resolveDefaultAuthor, buildRobotsMeta, resolvePostUrl, } from './seo-utils.js';
+/**
+ * Generates comprehensive metadata for a blog post
+ * @param post - The blog post
+ * @param config - SEO configuration
+ * @returns Metadata object for Next.js
+ */
+export function generateBlogPostMetadata(post, config) {
+    const blogConfig = config || getConfig();
+    const { siteName = DEFAULT_SITE_NAME, siteUrl = '', defaultAuthor, authors: configAuthors, twitterHandle, defaultOgImage, defaultLang = DEFAULT_LANG, alternateLanguages, } = blogConfig;
+    const fm = post.frontmatter;
+    // Title resolution: seoTitle > title > slug
+    const baseTitle = resolveFrontmatterField(['title'], fm, post.slug) || post.slug;
+    const seoTitle = resolveFrontmatterField(['seoTitle', 'title'], fm, baseTitle) || baseTitle;
+    const pageTitle = `${seoTitle} | ${siteName}`;
+    // Description resolution: seoDescription > description > excerpt > empty
+    const description = resolveFrontmatterField(['seoDescription', 'description', 'excerpt'], fm, '') || '';
+    // Use normalized authors from post, or fallback to default author (resolved from config if available)
+    // Note: post.authors should already be resolved from config.authors when the post was loaded (in file-utils.ts)
+    // However, we ensure they are resolved here as a safety net in case resolution didn't happen earlier
+    const resolvedDefaultAuthor = resolveDefaultAuthor(defaultAuthor, configAuthors);
+    const postAuthors = (post.authors && post.authors.length > 0)
+        ? post.authors
+        : (resolvedDefaultAuthor ? [resolvedDefaultAuthor] : []);
+    // Ensure all authors are resolved from config (safety net)
+    const authors = ensureAuthorsResolved(postAuthors, configAuthors);
+    const authorNames = getAuthorNames(authors);
+    // Extract author Twitter handles for Twitter metadata
+    // Works for both frontmatter authors (already resolved) and default author (just resolved above)
+    const authorTwitterHandles = authors
+        .map((author) => {
+        if (typeof author === 'string')
+            return undefined;
+        return author.twitter;
+    })
+        .filter((handle) => Boolean(handle));
+    // Date resolution: publishedDate > date
+    const publishedDate = resolveFrontmatterField(['publishedDate', 'date'], fm);
+    const modifiedDate = resolveFrontmatterField(['modifiedDate'], fm);
+    // Tags and keywords
+    const tags = isStringArray(fm.tags) ? fm.tags : [];
+    const keywords = normalizeKeywords(fm.keywords);
+    const allKeywords = [...tags, ...keywords].filter((k, i, arr) => arr.indexOf(k) === i); // Remove duplicates
+    // Calculate reading time if not provided
+    const readingTime = resolveFrontmatterField(['readingTime'], fm) || calculateReadingTime(post.content);
+    const wordCount = calculateWordCount(post.content);
+    // OG image resolution: ogImage > image > defaultOgImage
+    // If not provided, Next.js will automatically use opengraph-image.tsx file convention
+    const ogImageUrl = resolveFrontmatterField(['ogImage', 'image'], fm) ||
+        defaultOgImage;
+    const imageAlt = resolveFrontmatterField(['imageAlt'], fm) || seoTitle;
+    // OG title/description: ogTitle/ogDescription > seoTitle/seoDescription > title/description
+    const ogTitle = resolveFrontmatterField(['ogTitle'], fm) || seoTitle;
+    const ogDescription = resolveFrontmatterField(['ogDescription'], fm) || description;
+    // Twitter title/description: twitterTitle/twitterDescription > ogTitle/ogDescription > seoTitle/description
+    const twitterTitle = resolveFrontmatterField(['twitterTitle'], fm) || ogTitle;
+    const twitterDescription = resolveFrontmatterField(['twitterDescription'], fm) || ogDescription;
+    // Canonical URL - supports both absolute and relative URLs
+    // Relative URLs will be resolved against siteUrl
+    const canonicalUrl = resolvePostUrl(resolveFrontmatterField(['canonicalUrl'], fm), post.slug, siteUrl);
+    // Language
+    const lang = resolveFrontmatterField(['lang'], fm) || defaultLang;
+    // Robots meta
+    const robots = buildRobotsMeta(fm);
+    // Post URL
+    const postUrl = `${siteUrl}/blog/${post.slug}`;
+    // Article meta tags (for better SEO)
+    const articleMeta = {};
+    if (publishedDate)
+        articleMeta['article:published_time'] = publishedDate;
+    if (modifiedDate)
+        articleMeta['article:modified_time'] = modifiedDate;
+    const category = resolveFrontmatterField(['category'], fm);
+    if (category)
+        articleMeta['article:section'] = category;
+    if (tags.length > 0) {
+        tags.forEach((tag, index) => {
+            articleMeta[`article:tag${index > 0 ? index + 1 : ''}`] = tag;
+        });
+    }
+    if (authorNames.length > 0) {
+        authorNames.forEach((authorName, index) => {
+            articleMeta[`article:author${index > 0 ? index + 1 : ''}`] = authorName;
+        });
+    }
+    // Add author email and other details from Author objects to meta tags
+    authors.forEach((author, index) => {
+        if (typeof author === 'object') {
+            // Add author email if available
+            if (author.email) {
+                articleMeta[`author:email${index > 0 ? index + 1 : ''}`] = author.email;
+            }
+            // Add author URL if available
+            if (author.url) {
+                articleMeta[`author:url${index > 0 ? index + 1 : ''}`] = author.url;
+            }
+        }
+    });
+    // Build alternates object
+    const alternates = {};
+    if (canonicalUrl)
+        alternates.canonical = canonicalUrl;
+    if (alternateLanguages && Object.keys(alternateLanguages).length > 0) {
+        alternates.languages = alternateLanguages;
+    }
+    // Merge all custom meta tags into the 'other' field
+    const otherMeta = {};
+    if (lang)
+        otherMeta['lang'] = lang;
+    Object.assign(otherMeta, articleMeta);
+    const metadata = {
+        title: pageTitle,
+        description,
+        ...(Object.keys(alternates).length > 0 && { alternates }),
+        ...(robots && { robots }),
+        ...(Object.keys(otherMeta).length > 0 && { other: otherMeta }),
+        openGraph: {
+            title: ogTitle,
+            description: ogDescription,
+            type: 'article',
+            url: postUrl,
+            siteName,
+            ...(ogImageUrl && {
+                images: [
+                    {
+                        url: ogImageUrl,
+                        width: 1200,
+                        height: 630,
+                        alt: imageAlt,
+                    },
+                ],
+            }),
+            ...(publishedDate && { publishedTime: publishedDate }),
+            ...(modifiedDate && { modifiedTime: modifiedDate }),
+            ...(authorNames.length > 0 && { authors: authorNames }),
+            ...(tags.length > 0 && { tags }),
+            ...(lang && { locale: lang }),
+        },
+        twitter: {
+            card: 'summary_large_image',
+            title: twitterTitle,
+            description: twitterDescription,
+            ...(ogImageUrl && { images: [ogImageUrl] }),
+            // Use author's Twitter handle if available, otherwise fallback to site Twitter handle
+            ...(authorTwitterHandles.length > 0
+                ? { creator: `@${authorTwitterHandles[0].replace('@', '')}` }
+                : twitterHandle && { creator: `@${twitterHandle.replace('@', '')}` }),
+        },
+        ...(allKeywords.length > 0 && { keywords: allKeywords }),
+        ...(authors.length > 0 && {
+            authors: authors.map((author) => {
+                if (typeof author === 'string') {
+                    return { name: author };
+                }
+                return {
+                    name: author.name,
+                    ...(author.email && { email: author.email }),
+                    ...(author.url && { url: author.url }),
+                };
+            })
+        }),
+    };
+    return 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 function generateBlogListMetadata(posts, config) {
+    const blogConfig = config || getConfig();
+    const { siteName = DEFAULT_SITE_NAME, siteUrl = '' } = blogConfig;
+    const title = 'Blog Posts';
+    const description = `Browse all ${posts.length} blog posts`;
+    const metadata = {
+        title: `${title} | ${siteName}`,
+        description,
+        openGraph: {
+            title,
+            description,
+            type: 'website',
+            url: `${siteUrl}/blogs`,
+            siteName,
+        },
+        twitter: {
+            card: 'summary',
+            title,
+            description,
+        },
+    };
+    return metadata;
+}

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

@@ -0,0 +1,20 @@
+import type { BlogPost, Config } from './types.js';
+/**
+ * Generates JSON-LD structured data (Schema.org) for a blog post
+ * @param post - The blog post
+ * @param config - SEO configuration
+ * @returns JSON-LD schema object
+ */
+export declare function generateBlogPostSchema(post: BlogPost, config?: Config): Record<string, unknown>;
+/**
+ * Generates breadcrumbs schema for a blog post
+ * @param post - The blog post
+ * @param config - SEO configuration
+ * @param breadcrumbs - Optional custom breadcrumb items (e.g., [{ name: 'Home', url: '/' }, { name: 'Blog', url: '/blog' }])
+ * @returns Breadcrumbs JSON-LD schema object
+ */
+export declare function generateBreadcrumbsSchema(post: BlogPost, config?: Config, breadcrumbs?: Array<{
+    name: string;
+    url: string;
+}>): Record<string, unknown>;
+//# sourceMappingURL=seo-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seo-schema.d.ts","sourceRoot":"","sources":["../../src/core/seo-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAU,MAAM,EAAE,MAAM,YAAY,CAAC;AAY3D;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,QAAQ,EACd,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8GzB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,MAAM,CAAC,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GACjD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiCzB"}

package/dist/core/seo-schema.js

@@ -0,0 +1,131 @@
+import { calculateReadingTime, calculateWordCount } from './utils.js';
+import { getConfig } from './config.js';
+import { resolveFrontmatterField, isStringArray } from './type-guards.js';
+import { DEFAULT_SITE_NAME } from './constants.js';
+import { ensureAuthorsResolved, resolveDefaultAuthor, getAuthorNames, resolvePostUrl, } from './seo-utils.js';
+/**
+ * Generates JSON-LD structured data (Schema.org) for a blog post
+ * @param post - The blog post
+ * @param config - SEO configuration
+ * @returns JSON-LD schema object
+ */
+export function generateBlogPostSchema(post, config) {
+    const blogConfig = config || getConfig();
+    const { siteName = DEFAULT_SITE_NAME, siteUrl = '', defaultAuthor, authors: configAuthors, } = blogConfig;
+    const fm = post.frontmatter;
+    const title = resolveFrontmatterField(['seoTitle', 'title'], fm, post.slug) || post.slug;
+    const description = resolveFrontmatterField(['seoDescription', 'description', 'excerpt'], fm, '') || '';
+    // Use normalized authors from post, or fallback to default author (resolved from config if available)
+    // Note: post.authors should already be resolved from config.authors when the post was loaded (in file-utils.ts)
+    // However, we ensure they are resolved here as a safety net in case resolution didn't happen earlier
+    const resolvedDefaultAuthor = resolveDefaultAuthor(defaultAuthor, configAuthors);
+    const postAuthors = (post.authors && post.authors.length > 0)
+        ? post.authors
+        : (resolvedDefaultAuthor ? [resolvedDefaultAuthor] : []);
+    // Ensure all authors are resolved from config (safety net)
+    const authors = ensureAuthorsResolved(postAuthors, configAuthors);
+    const authorNames = getAuthorNames(authors);
+    const publishedDate = resolveFrontmatterField(['publishedDate', 'date'], fm);
+    const modifiedDate = resolveFrontmatterField(['modifiedDate'], fm) || publishedDate;
+    const postUrl = resolvePostUrl(resolveFrontmatterField(['canonicalUrl'], fm), post.slug, siteUrl);
+    const ogImageUrl = resolveFrontmatterField(['ogImage', 'image'], fm);
+    // Calculate reading time and word count if not provided
+    const readingTime = resolveFrontmatterField(['readingTime'], fm) || calculateReadingTime(post.content);
+    const wordCount = calculateWordCount(post.content);
+    // Build author schema with full author info if available
+    const buildAuthorSchema = (author) => {
+        if (typeof author === 'string') {
+            return {
+                '@type': 'Person',
+                name: author,
+            };
+        }
+        return {
+            '@type': 'Person',
+            name: author.name,
+            ...(author.email && { email: author.email }),
+            ...(author.url && { url: author.url }),
+            ...(author.avatar && { image: author.avatar }),
+        };
+    };
+    // Base schema
+    const schema = {
+        '@context': 'https://schema.org',
+        '@type': resolveFrontmatterField(['type'], fm, 'BlogPosting') || 'BlogPosting',
+        headline: title,
+        description,
+        url: postUrl,
+        mainEntityOfPage: {
+            '@type': 'WebPage',
+            '@id': postUrl,
+        },
+        ...(publishedDate && { datePublished: publishedDate }),
+        ...(modifiedDate && { dateModified: modifiedDate }),
+        ...(authors.length > 0 && {
+            author: authors.length === 1
+                ? buildAuthorSchema(authors[0])
+                : authors.map(buildAuthorSchema),
+        }),
+        ...(siteName && {
+            publisher: {
+                '@type': 'Organization',
+                name: siteName,
+                ...(siteUrl && { url: siteUrl }),
+            },
+        }),
+        ...(ogImageUrl && {
+            image: {
+                '@type': 'ImageObject',
+                url: ogImageUrl,
+                ...(resolveFrontmatterField(['imageAlt'], fm) ? { caption: resolveFrontmatterField(['imageAlt'], fm) } : {}),
+            },
+        }),
+        ...(resolveFrontmatterField(['category'], fm) ? { articleSection: resolveFrontmatterField(['category'], fm) } : {}),
+        ...(isStringArray(fm.tags) && fm.tags.length > 0 && {
+            keywords: fm.tags.join(', '),
+        }),
+        ...(resolveFrontmatterField(['lang'], fm) ? { inLanguage: resolveFrontmatterField(['lang'], fm) } : {}),
+        ...(wordCount > 0 && { wordCount }),
+        ...(readingTime > 0 && {
+            timeRequired: `PT${readingTime}M`,
+        }),
+    };
+    // Merge with custom schema from frontmatter
+    if (fm.schema && typeof fm.schema === 'object') {
+        return {
+            ...schema,
+            ...fm.schema,
+        };
+    }
+    return schema;
+}
+/**
+ * Generates breadcrumbs schema for a blog post
+ * @param post - The blog post
+ * @param config - SEO configuration
+ * @param breadcrumbs - Optional custom breadcrumb items (e.g., [{ name: 'Home', url: '/' }, { name: 'Blog', url: '/blog' }])
+ * @returns Breadcrumbs JSON-LD schema object
+ */
+export function generateBreadcrumbsSchema(post, config, breadcrumbs) {
+    const blogConfig = config || getConfig();
+    const { siteUrl = '' } = blogConfig;
+    const title = resolveFrontmatterField(['seoTitle', 'title'], post.frontmatter, post.slug) || post.slug;
+    const postUrl = resolvePostUrl(resolveFrontmatterField(['canonicalUrl'], post.frontmatter), post.slug, siteUrl);
+    // Default breadcrumbs: Home > Blog > Post
+    const defaultBreadcrumbs = [
+        { name: 'Home', url: siteUrl || '/' },
+        { name: 'Blog', url: `${siteUrl}/blogs` },
+        { name: title, url: postUrl },
+    ];
+    const items = breadcrumbs || defaultBreadcrumbs;
+    return {
+        '@context': 'https://schema.org',
+        '@type': 'BreadcrumbList',
+        itemListElement: items.map((item, index) => ({
+            '@type': 'ListItem',
+            position: index + 1,
+            name: item.name,
+            item: item.url,
+        })),
+    };
+}

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

@@ -0,0 +1,66 @@
+import type { BlogPost, Author } from './types.js';
+/**
+ * Normalizes keywords to an array of strings
+ * Handles both string (comma-separated) and array formats
+ * @param keywords - Keywords as string (comma-separated) or array of strings
+ * @returns Array of normalized keyword strings
+ */
+export declare function normalizeKeywords(keywords?: string | string[]): string[];
+/**
+ * Extracts author name from string or Author object
+ * @param author - Author as string or Author object
+ * @returns Author name as string
+ */
+export declare function getAuthorName(author: string | Author): string;
+/**
+ * Converts authors array (string | Author)[] to array of author names
+ * @param authors - Array of authors (strings or Author objects)
+ * @returns Array of author names as strings
+ */
+export declare function getAuthorNames(authors: (string | Author)[]): string[];
+/**
+ * Ensures all authors in the array are resolved from config
+ * This is a safety net to ensure authors are resolved even if they weren't resolved earlier
+ * @param authors - Array of authors (strings or Author objects)
+ * @param configAuthors - Array of authors from config
+ * @returns Array of resolved authors (Author objects or strings)
+ */
+export declare function ensureAuthorsResolved(authors: (string | Author)[], configAuthors?: Author[]): (string | Author)[];
+/**
+ * Resolves defaultAuthor from config.authors array if available
+ * @param defaultAuthor - Default author name from config
+ * @param configAuthors - Array of authors from config
+ * @returns Author object if found, otherwise returns the name as string
+ */
+export declare function resolveDefaultAuthor(defaultAuthor: string | undefined, configAuthors?: Author[]): string | Author | undefined;
+/**
+ * Builds robots meta string from frontmatter
+ * Combines robots directive string with boolean flags (noindex, nofollow)
+ * @param frontmatter - Blog post frontmatter containing robots directives
+ * @returns Robots meta string (e.g., 'noindex, nofollow') or undefined
+ */
+export declare function buildRobotsMeta(frontmatter: BlogPost['frontmatter']): string | undefined;
+/**
+ * Resolves a URL to an absolute URL
+ * If the URL is already absolute (starts with http:// or https://), returns it as-is
+ * If the URL is relative (starts with /), resolves it against siteUrl
+ * @param url - The URL to resolve (can be absolute or relative)
+ * @param siteUrl - The base site URL to resolve relative URLs against
+ * @returns Absolute URL
+ */
+export declare function resolveCanonicalUrl(url: string, siteUrl: string): string;
+/**
+ * Resolves a post URL from canonical URL or generates default
+ * @param canonicalUrl - Optional canonical URL from frontmatter
+ * @param slug - Post slug
+ * @param siteUrl - Base site URL
+ * @returns Resolved absolute URL
+ */
+export declare function resolvePostUrl(canonicalUrl: string | undefined, slug: string, siteUrl: string): string;
+/**
+ * Escapes XML special characters to prevent injection attacks
+ * @param unsafe - String that may contain XML special characters
+ * @returns Escaped string safe for XML output
+ */
+export declare function escapeXml(unsafe: string): string;
+//# sourceMappingURL=seo-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seo-utils.d.ts","sourceRoot":"","sources":["../../src/core/seo-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAInD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAOxE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM,EAAE,CAErE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAC5B,aAAa,CAAC,EAAE,MAAM,EAAE,GACvB,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAcrB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,aAAa,CAAC,EAAE,MAAM,EAAE,GACvB,MAAM,GAAG,MAAM,GAAG,SAAS,CAI7B;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,QAAQ,CAAC,aAAa,CAAC,GAAG,MAAM,GAAG,SAAS,CAqBxF;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAgBxE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,CAGR;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAOhD"}

package/dist/core/seo-utils.js

@@ -0,0 +1,135 @@
+import { resolveAuthorFromConfig } from './utils.js';
+/**
+ * Normalizes keywords to an array of strings
+ * Handles both string (comma-separated) and array formats
+ * @param keywords - Keywords as string (comma-separated) or array of strings
+ * @returns Array of normalized keyword strings
+ */
+export function normalizeKeywords(keywords) {
+    if (!keywords)
+        return [];
+    if (Array.isArray(keywords))
+        return keywords;
+    if (typeof keywords === 'string') {
+        return keywords.split(',').map((k) => k.trim()).filter(Boolean);
+    }
+    return [];
+}
+/**
+ * Extracts author name from string or Author object
+ * @param author - Author as string or Author object
+ * @returns Author name as string
+ */
+export function getAuthorName(author) {
+    return typeof author === 'string' ? author : author.name;
+}
+/**
+ * Converts authors array (string | Author)[] to array of author names
+ * @param authors - Array of authors (strings or Author objects)
+ * @returns Array of author names as strings
+ */
+export function getAuthorNames(authors) {
+    return authors.map(getAuthorName);
+}
+/**
+ * Ensures all authors in the array are resolved from config
+ * This is a safety net to ensure authors are resolved even if they weren't resolved earlier
+ * @param authors - Array of authors (strings or Author objects)
+ * @param configAuthors - Array of authors from config
+ * @returns Array of resolved authors (Author objects or strings)
+ */
+export function ensureAuthorsResolved(authors, configAuthors) {
+    if (!configAuthors || configAuthors.length === 0) {
+        return authors;
+    }
+    return authors.map((author) => {
+        // If already an Author object, return as-is
+        if (typeof author === 'object') {
+            return author;
+        }
+        // If it's a string, try to resolve it from config
+        return resolveAuthorFromConfig(author, configAuthors);
+    });
+}
+/**
+ * Resolves defaultAuthor from config.authors array if available
+ * @param defaultAuthor - Default author name from config
+ * @param configAuthors - Array of authors from config
+ * @returns Author object if found, otherwise returns the name as string
+ */
+export function resolveDefaultAuthor(defaultAuthor, configAuthors) {
+    if (!defaultAuthor)
+        return undefined;
+    return resolveAuthorFromConfig(defaultAuthor, configAuthors);
+}
+/**
+ * Builds robots meta string from frontmatter
+ * Combines robots directive string with boolean flags (noindex, nofollow)
+ * @param frontmatter - Blog post frontmatter containing robots directives
+ * @returns Robots meta string (e.g., 'noindex, nofollow') or undefined
+ */
+export function buildRobotsMeta(frontmatter) {
+    const directives = [];
+    const robots = typeof frontmatter.robots === 'string' ? frontmatter.robots : undefined;
+    if (frontmatter.noindex || (robots && robots.includes('noindex'))) {
+        directives.push('noindex');
+    }
+    if (frontmatter.nofollow || (robots && robots.includes('nofollow'))) {
+        directives.push('nofollow');
+    }
+    // If explicit robots string is provided, use it (unless overridden by boolean flags)
+    if (robots && !frontmatter.noindex && !frontmatter.nofollow) {
+        return robots;
+    }
+    if (directives.length > 0) {
+        return directives.join(', ');
+    }
+    return undefined;
+}
+/**
+ * Resolves a URL to an absolute URL
+ * If the URL is already absolute (starts with http:// or https://), returns it as-is
+ * If the URL is relative (starts with /), resolves it against siteUrl
+ * @param url - The URL to resolve (can be absolute or relative)
+ * @param siteUrl - The base site URL to resolve relative URLs against
+ * @returns Absolute URL
+ */
+export function resolveCanonicalUrl(url, siteUrl) {
+    // If already absolute, return as-is
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+        return url;
+    }
+    // If relative, resolve against siteUrl
+    if (url.startsWith('/')) {
+        // Remove trailing slash from siteUrl if present
+        const baseUrl = siteUrl.replace(/\/$/, '');
+        return `${baseUrl}${url}`;
+    }
+    // If it's a relative path without leading slash, treat it as relative to root
+    const baseUrl = siteUrl.replace(/\/$/, '');
+    return `${baseUrl}/${url}`;
+}
+/**
+ * Resolves a post URL from canonical URL or generates default
+ * @param canonicalUrl - Optional canonical URL from frontmatter
+ * @param slug - Post slug
+ * @param siteUrl - Base site URL
+ * @returns Resolved absolute URL
+ */
+export function resolvePostUrl(canonicalUrl, slug, siteUrl) {
+    const urlRaw = canonicalUrl || `${siteUrl}/blog/${slug}`;
+    return siteUrl ? resolveCanonicalUrl(urlRaw, siteUrl) : urlRaw;
+}
+/**
+ * Escapes XML special characters to prevent injection attacks
+ * @param unsafe - String that may contain XML special characters
+ * @returns Escaped string safe for XML output
+ */
+export function escapeXml(unsafe) {
+    return unsafe
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}

package/dist/core/seo.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SEO utilities and generators for next-md-blog
+ *
+ * This module provides functions for generating metadata, schema.org structured data,
+ * and RSS/sitemap feeds for blog posts.
+ */
+export { generateBlogPostMetadata, generateBlogListMetadata, } from './seo-metadata.js';
+export { generateBlogPostSchema, generateBreadcrumbsSchema, } from './seo-schema.js';
+export { generateSitemap, generateRSSFeed, } from './seo-feeds.js';
+export { normalizeKeywords, getAuthorName, getAuthorNames, ensureAuthorsResolved, resolveDefaultAuthor, buildRobotsMeta, resolveCanonicalUrl, resolvePostUrl, escapeXml, } from './seo-utils.js';
+//# sourceMappingURL=seo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seo.d.ts","sourceRoot":"","sources":["../../src/core/seo.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,eAAe,EACf,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,SAAS,GACV,MAAM,gBAAgB,CAAC"}

package/dist/core/seo.js

@@ -0,0 +1,12 @@
+/**
+ * SEO utilities and generators for next-md-blog
+ *
+ * This module provides functions for generating metadata, schema.org structured data,
+ * and RSS/sitemap feeds for blog posts.
+ */
+// Re-export all SEO functions from their respective modules
+export { generateBlogPostMetadata, generateBlogListMetadata, } from './seo-metadata.js';
+export { generateBlogPostSchema, generateBreadcrumbsSchema, } from './seo-schema.js';
+export { generateSitemap, generateRSSFeed, } from './seo-feeds.js';
+// Re-export utility functions that might be useful
+export { normalizeKeywords, getAuthorName, getAuthorNames, ensureAuthorsResolved, resolveDefaultAuthor, buildRobotsMeta, resolveCanonicalUrl, resolvePostUrl, escapeXml, } from './seo-utils.js';

package/dist/core/type-guards.d.ts

@@ -0,0 +1,58 @@
+import type { BlogPostFrontmatter, Author } from './types.js';
+/**
+ * Type guard to check if a value is a non-empty string
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Type guard to check if a value is a string array
+ */
+export declare function isStringArray(value: unknown): value is string[];
+/**
+ * Type guard to check if a value is a number
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Type guard to check if a value is an Author object
+ */
+export declare function isAuthorObject(value: unknown): value is {
+    name: string;
+    [key: string]: unknown;
+};
+/**
+ * Type guard to check if a value is an Author
+ */
+export declare function isAuthor(value: unknown): value is Author;
+/**
+ * Gets a string field from frontmatter with fallback
+ * @param frontmatter - Blog post frontmatter object
+ * @param field - Field name to extract
+ * @param fallback - Optional fallback value if field is missing or invalid
+ * @returns String value or undefined
+ */
+export declare function getStringField(frontmatter: BlogPostFrontmatter, field: keyof BlogPostFrontmatter, fallback?: string): string | undefined;
+/**
+ * Gets a number field from frontmatter with fallback
+ * @param frontmatter - Blog post frontmatter object
+ * @param field - Field name to extract
+ * @param fallback - Optional fallback value if field is missing or invalid
+ * @returns Number value or undefined
+ */
+export declare function getNumberField(frontmatter: BlogPostFrontmatter, field: keyof BlogPostFrontmatter, fallback?: number): number | undefined;
+/**
+ * Resolves a frontmatter field from multiple possible field names
+ * Checks fields in order and returns the first valid value found
+ * @param fields - Array of field names to check (in priority order)
+ * @param frontmatter - Blog post frontmatter object
+ * @param fallback - Optional fallback value if no fields are found
+ * @returns First valid field value or fallback
+ * @example
+ * ```typescript
+ * const title = resolveFrontmatterField<string>(
+ *   ['seoTitle', 'title'],
+ *   frontmatter,
+ *   'Default Title'
+ * );
+ * ```
+ */
+export declare function resolveFrontmatterField<T>(fields: Array<keyof BlogPostFrontmatter>, frontmatter: BlogPostFrontmatter, fallback?: T): T | undefined;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/core/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../src/core/type-guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAE9D;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,EAAE,CAE/D;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAOnD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAOxD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,MAAM,mBAAmB,EAChC,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,MAAM,mBAAmB,EAChC,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,MAAM,EAAE,KAAK,CAAC,MAAM,mBAAmB,CAAC,EACxC,WAAW,EAAE,mBAAmB,EAChC,QAAQ,CAAC,EAAE,CAAC,GACX,CAAC,GAAG,SAAS,CAQf"}