@stati/core 1.6.4 → 1.7.1

package/dist/seo/generator.d.ts

@@ -0,0 +1,77 @@
+/**
+ * SEO metadata generation module
+ * Generates meta tags, Open Graph tags, Twitter Cards, and structured data
+ */
+import type { SEOContext } from '../types/seo.js';
+import type { PageModel } from '../types/content.js';
+import type { StatiConfig, SiteConfig } from '../types/config.js';
+import { SEOTagType } from '../types/seo.js';
+/**
+ * Generate complete SEO metadata for a page.
+ * Supports both whitelist (include) and blacklist (exclude) modes for selective tag generation.
+ *
+ * Note: Validation errors are logged as warnings rather than throwing to allow builds to
+ * continue with degraded SEO. This prevents a single SEO issue from blocking the entire build.
+ *
+ * @param ctx - SEO context containing page, config, siteUrl, and optional include/exclude sets
+ * @returns HTML string containing all generated SEO tags
+ *
+ * @example
+ * ```typescript
+ * const seoTags = generateSEOMetadata({
+ *   page,
+ *   config,
+ *   siteUrl: 'https://example.com',
+ *   exclude: new Set([SEOTagType.Twitter]) // Skip Twitter tags
+ * });
+ * ```
+ */
+export declare function generateSEOMetadata(ctx: SEOContext): string;
+/**
+ * Generate Open Graph protocol meta tags.
+ * Implements fallback chains for all OG properties to ensure complete metadata.
+ *
+ * @param ctx - SEO context containing page, config, and siteUrl
+ * @returns Array of Open Graph meta tag strings
+ *
+ * @example
+ * ```typescript
+ * const ogTags = generateOpenGraphTags(ctx);
+ * // Returns: ['<meta property="og:title" content="...">', ...]
+ * ```
+ */
+export declare function generateOpenGraphTags(ctx: SEOContext): string[];
+/**
+ * Generate Twitter Card meta tags.
+ * Implements fallback chains to ensure complete card metadata.
+ *
+ * @param ctx - SEO context containing page, config, and siteUrl
+ * @returns Array of Twitter Card meta tag strings
+ *
+ * @example
+ * ```typescript
+ * const twitterTags = generateTwitterCardTags(ctx);
+ * // Returns: ['<meta name="twitter:card" content="summary_large_image">', ...]
+ * ```
+ */
+export declare function generateTwitterCardTags(ctx: SEOContext): string[];
+/**
+ * Template helper function for generating SEO tags in Eta templates.
+ * Provides a convenient API for selective SEO tag generation.
+ *
+ * @param context - Object containing page, config, and optional site
+ * @param tags - Optional array of tag types to generate (strings or SEOTagType enums)
+ * @returns HTML string containing generated SEO tags
+ *
+ * @example
+ * ```eta
+ * <%~ stati.generateSEO(stati) %>
+ * <%~ stati.generateSEO(stati, ['title', 'description', 'opengraph']) %>
+ * ```
+ */
+export declare function generateSEO(context: {
+    page: PageModel;
+    config: StatiConfig;
+    site?: SiteConfig;
+}, tags?: Array<SEOTagType | string>): string;
+//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/seo/generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAElE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAsH3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,EAAE,CAyE/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,EAAE,CAuDjE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE;IACP,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,WAAW,CAAC;IACpB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB,EACD,IAAI,CAAC,EAAE,KAAK,CAAC,UAAU,GAAG,MAAM,CAAC,GAChC,MAAM,CA6CR"}

package/dist/seo/generator.js

@@ -0,0 +1,320 @@
+/**
+ * SEO metadata generation module
+ * Generates meta tags, Open Graph tags, Twitter Cards, and structured data
+ */
+import { SEOTagType } from '../types/seo.js';
+import { escapeHtml, validateSEOMetadata, generateRobotsContent } from './utils/index.js';
+import { sanitizeStructuredData } from './utils/escape-and-validation.js';
+/**
+ * Generate complete SEO metadata for a page.
+ * Supports both whitelist (include) and blacklist (exclude) modes for selective tag generation.
+ *
+ * Note: Validation errors are logged as warnings rather than throwing to allow builds to
+ * continue with degraded SEO. This prevents a single SEO issue from blocking the entire build.
+ *
+ * @param ctx - SEO context containing page, config, siteUrl, and optional include/exclude sets
+ * @returns HTML string containing all generated SEO tags
+ *
+ * @example
+ * ```typescript
+ * const seoTags = generateSEOMetadata({
+ *   page,
+ *   config,
+ *   siteUrl: 'https://example.com',
+ *   exclude: new Set([SEOTagType.Twitter]) // Skip Twitter tags
+ * });
+ * ```
+ */
+export function generateSEOMetadata(ctx) {
+    const { page, config, siteUrl, exclude, include, logger } = ctx;
+    const seo = page.frontMatter.seo || {};
+    // Validate SEO metadata
+    const validation = validateSEOMetadata(seo, page.url);
+    // Log validation errors as warnings instead of throwing
+    // This allows builds to continue even with SEO issues
+    if (!validation.valid) {
+        logger.warning(`SEO validation failed for ${page.url}:`);
+        validation.errors.forEach((error) => {
+            logger.warning(`  - ${error}`);
+        });
+        if (config.seo?.debug) {
+            logger.warning('Build will continue, but SEO metadata may be incomplete or invalid.');
+        }
+    }
+    // Log warnings if any and debug is enabled
+    if (validation.warnings.length > 0 && config.seo?.debug) {
+        logger.warning(`SEO warnings for ${page.url}:`);
+        validation.warnings.forEach((warning) => {
+            logger.warning(`  - ${warning}`);
+        });
+    }
+    const meta = [];
+    /**
+     * Helper function to determine if a specific tag type should be generated.
+     *
+     * Three modes:
+     * 1. Whitelist mode (include set provided): Only generate tags in the include set
+     * 2. Blacklist mode (exclude set provided): Generate all tags except those in exclude set
+     * 3. Default mode (neither provided): Generate all tags
+     *
+     * @param tagType - The SEO tag type to check
+     * @returns True if the tag should be generated
+     */
+    const shouldGenerate = (tagType) => {
+        // Whitelist mode: only generate explicitly included tags
+        if (include) {
+            return include.has(tagType);
+        }
+        // Blacklist mode: generate unless explicitly excluded
+        if (exclude) {
+            return !exclude.has(tagType);
+        }
+        // Default: generate all tags
+        return true;
+    };
+    // Title tag
+    if (shouldGenerate(SEOTagType.Title)) {
+        const title = seo.title || page.frontMatter.title || config.site.title;
+        meta.push(`<title>${escapeHtml(title)}</title>`);
+    }
+    // Description meta tag
+    if (shouldGenerate(SEOTagType.Description)) {
+        const description = seo.description || page.frontMatter.description;
+        if (description) {
+            meta.push(`<meta name="description" content="${escapeHtml(description)}">`);
+        }
+    }
+    // Keywords meta tag
+    if (shouldGenerate(SEOTagType.Keywords)) {
+        const keywords = seo.keywords || page.frontMatter.tags;
+        if (keywords && keywords.length > 0) {
+            const keywordsArray = Array.isArray(keywords) ? keywords : [keywords];
+            meta.push(`<meta name="keywords" content="${keywordsArray.map(escapeHtml).join(', ')}">`);
+        }
+    }
+    // Canonical link
+    if (shouldGenerate(SEOTagType.Canonical)) {
+        const canonical = seo.canonical || `${siteUrl}${page.url}`;
+        meta.push(`<link rel="canonical" href="${escapeHtml(canonical)}">`);
+    }
+    // Robots meta tag
+    if (shouldGenerate(SEOTagType.Robots)) {
+        const robotsContent = generateRobotsContent(seo);
+        if (robotsContent) {
+            meta.push(`<meta name="robots" content="${robotsContent}">`);
+        }
+    }
+    // Author meta tag
+    if (shouldGenerate(SEOTagType.Author)) {
+        const author = seo.author || config.seo?.defaultAuthor;
+        if (author) {
+            const authorName = typeof author === 'string' ? author : author.name;
+            meta.push(`<meta name="author" content="${escapeHtml(authorName)}">`);
+        }
+    }
+    // Open Graph tags
+    if (shouldGenerate(SEOTagType.OpenGraph)) {
+        meta.push(...generateOpenGraphTags(ctx));
+    }
+    // Twitter Card tags
+    if (shouldGenerate(SEOTagType.Twitter)) {
+        meta.push(...generateTwitterCardTags(ctx));
+    }
+    // JSON-LD Structured Data
+    if (shouldGenerate(SEOTagType.StructuredData) && seo.structuredData) {
+        const sanitized = sanitizeStructuredData(seo.structuredData, logger);
+        meta.push(`<script type="application/ld+json">${JSON.stringify(sanitized)}</script>`);
+    }
+    return meta.join('\n  ');
+}
+/**
+ * Generate Open Graph protocol meta tags.
+ * Implements fallback chains for all OG properties to ensure complete metadata.
+ *
+ * @param ctx - SEO context containing page, config, and siteUrl
+ * @returns Array of Open Graph meta tag strings
+ *
+ * @example
+ * ```typescript
+ * const ogTags = generateOpenGraphTags(ctx);
+ * // Returns: ['<meta property="og:title" content="...">', ...]
+ * ```
+ */
+export function generateOpenGraphTags(ctx) {
+    const { page, config, siteUrl } = ctx;
+    const seo = page.frontMatter.seo || {};
+    const og = seo.openGraph || {};
+    const tags = [];
+    // Basic OG tags with fallback chain
+    const ogTitle = og.title || seo.title || page.frontMatter.title || config.site.title;
+    const ogDescription = og.description || seo.description || page.frontMatter.description;
+    const ogUrl = og.url || seo.canonical || `${siteUrl}${page.url}`;
+    const ogType = og.type || 'website';
+    const ogSiteName = og.siteName || config.site.title;
+    tags.push(`<meta property="og:title" content="${escapeHtml(ogTitle)}">`);
+    if (ogDescription) {
+        tags.push(`<meta property="og:description" content="${escapeHtml(ogDescription)}">`);
+    }
+    tags.push(`<meta property="og:url" content="${escapeHtml(ogUrl)}">`);
+    tags.push(`<meta property="og:type" content="${escapeHtml(ogType)}">`);
+    tags.push(`<meta property="og:site_name" content="${escapeHtml(ogSiteName)}">`);
+    // OG Image
+    if (og.image) {
+        const image = typeof og.image === 'string' ? { url: og.image } : og.image;
+        const imageUrl = image.url.startsWith('/') ? `${siteUrl}${image.url}` : image.url;
+        tags.push(`<meta property="og:image" content="${escapeHtml(imageUrl)}">`);
+        if (image.alt) {
+            tags.push(`<meta property="og:image:alt" content="${escapeHtml(image.alt)}">`);
+        }
+        if (image.width) {
+            tags.push(`<meta property="og:image:width" content="${image.width}">`);
+        }
+        if (image.height) {
+            tags.push(`<meta property="og:image:height" content="${image.height}">`);
+        }
+    }
+    // OG Locale
+    if (og.locale || config.site.defaultLocale) {
+        const locale = og.locale || config.site.defaultLocale;
+        if (locale) {
+            tags.push(`<meta property="og:locale" content="${escapeHtml(locale)}">`);
+        }
+    }
+    // OG Article metadata (only for article type)
+    if (og.article && ogType === 'article') {
+        const article = og.article;
+        if (article.publishedTime) {
+            tags.push(`<meta property="article:published_time" content="${escapeHtml(article.publishedTime)}">`);
+        }
+        if (article.modifiedTime) {
+            tags.push(`<meta property="article:modified_time" content="${escapeHtml(article.modifiedTime)}">`);
+        }
+        if (article.author) {
+            tags.push(`<meta property="article:author" content="${escapeHtml(article.author)}">`);
+        }
+        if (article.section) {
+            tags.push(`<meta property="article:section" content="${escapeHtml(article.section)}">`);
+        }
+        if (article.tags && article.tags.length > 0) {
+            article.tags.forEach((tag) => {
+                tags.push(`<meta property="article:tag" content="${escapeHtml(tag)}">`);
+            });
+        }
+    }
+    return tags;
+}
+/**
+ * Generate Twitter Card meta tags.
+ * Implements fallback chains to ensure complete card metadata.
+ *
+ * @param ctx - SEO context containing page, config, and siteUrl
+ * @returns Array of Twitter Card meta tag strings
+ *
+ * @example
+ * ```typescript
+ * const twitterTags = generateTwitterCardTags(ctx);
+ * // Returns: ['<meta name="twitter:card" content="summary_large_image">', ...]
+ * ```
+ */
+export function generateTwitterCardTags(ctx) {
+    const { page, config, siteUrl } = ctx;
+    const seo = page.frontMatter.seo || {};
+    const twitter = seo.twitter || {};
+    const tags = [];
+    // Card type
+    const card = twitter.card || 'summary_large_image';
+    tags.push(`<meta name="twitter:card" content="${card}">`);
+    // Twitter site (optional)
+    if (twitter.site) {
+        tags.push(`<meta name="twitter:site" content="${escapeHtml(twitter.site)}">`);
+    }
+    // Twitter creator with fallback chain
+    if (twitter.creator) {
+        tags.push(`<meta name="twitter:creator" content="${escapeHtml(twitter.creator)}">`);
+    }
+    else if (seo.author) {
+        const authorName = typeof seo.author === 'string' ? seo.author : seo.author.name;
+        tags.push(`<meta name="twitter:creator" content="${escapeHtml(authorName)}">`);
+    }
+    else if (config.seo?.defaultAuthor) {
+        tags.push(`<meta name="twitter:creator" content="${escapeHtml(config.seo.defaultAuthor.name)}">`);
+    }
+    // Title and description with fallback chains
+    const twitterTitle = twitter.title || seo.title || page.frontMatter.title || config.site.title;
+    const twitterDescription = twitter.description || seo.description || page.frontMatter.description;
+    tags.push(`<meta name="twitter:title" content="${escapeHtml(twitterTitle)}">`);
+    if (twitterDescription) {
+        tags.push(`<meta name="twitter:description" content="${escapeHtml(twitterDescription)}">`);
+    }
+    // Image with fallback to Open Graph image
+    const imageUrl = twitter.image ||
+        (seo.openGraph?.image
+            ? typeof seo.openGraph.image === 'string'
+                ? seo.openGraph.image
+                : seo.openGraph.image.url
+            : undefined);
+    if (imageUrl) {
+        const fullImageUrl = imageUrl.startsWith('/') ? `${siteUrl}${imageUrl}` : imageUrl;
+        tags.push(`<meta name="twitter:image" content="${escapeHtml(fullImageUrl)}">`);
+        if (twitter.imageAlt) {
+            tags.push(`<meta name="twitter:image:alt" content="${escapeHtml(twitter.imageAlt)}">`);
+        }
+    }
+    return tags;
+}
+/**
+ * Template helper function for generating SEO tags in Eta templates.
+ * Provides a convenient API for selective SEO tag generation.
+ *
+ * @param context - Object containing page, config, and optional site
+ * @param tags - Optional array of tag types to generate (strings or SEOTagType enums)
+ * @returns HTML string containing generated SEO tags
+ *
+ * @example
+ * ```eta
+ * <%~ stati.generateSEO(stati) %>
+ * <%~ stati.generateSEO(stati, ['title', 'description', 'opengraph']) %>
+ * ```
+ */
+export function generateSEO(context, tags) {
+    // Convert tag names to SEOTagType enum values
+    let include = undefined;
+    if (tags && tags.length > 0) {
+        include = new Set();
+        for (const tag of tags) {
+            if (typeof tag === 'string') {
+                // Convert string to enum by checking if the string matches any enum value
+                // The enum values are lowercase strings like 'title', 'description', etc.
+                const enumEntry = Object.entries(SEOTagType).find(([_, value]) => value === tag);
+                if (enumEntry) {
+                    include.add(enumEntry[1]);
+                }
+            }
+            else {
+                include.add(tag);
+            }
+        }
+    }
+    // Extract site URL from config
+    const siteUrl = context.config.site?.baseUrl || context.site?.baseUrl || '';
+    // Generate SEO metadata with a no-op logger (warnings won't be shown in template context)
+    const noOpLogger = {
+        info: () => { },
+        success: () => { },
+        warning: () => { },
+        error: () => { },
+        building: () => { },
+        processing: () => { },
+        stats: () => { },
+    };
+    const seoContext = {
+        page: context.page,
+        config: context.config,
+        siteUrl,
+        logger: noOpLogger,
+    };
+    if (include) {
+        seoContext.include = include;
+    }
+    return generateSEOMetadata(seoContext);
+}

package/dist/seo/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview SEO functionality exports
+ * Barrel file for all Stati SEO functionality including metadata generation,
+ * sitemaps, robots.txt, and auto-injection.
+ */
+export { generateSEOMetadata, generateSEO, generateOpenGraphTags, generateTwitterCardTags, } from './generator.js';
+export { generateSitemap, generateSitemapEntry, generateSitemapXml, generateSitemapIndexXml, } from './sitemap.js';
+export { generateRobotsTxt, generateRobotsTxtFromConfig } from './robots.js';
+export { autoInjectSEO, shouldAutoInject } from './auto-inject.js';
+export type { AutoInjectOptions } from './auto-inject.js';
+export { escapeHtml, generateRobotsContent, validateSEOMetadata, detectExistingSEOTags, normalizeUrlPath, resolveAbsoluteUrl, isValidUrl, } from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/seo/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAG7E,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACnE,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,OAAO,EACL,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,GACX,MAAM,kBAAkB,CAAC"}

package/dist/seo/index.js

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview SEO functionality exports
+ * Barrel file for all Stati SEO functionality including metadata generation,
+ * sitemaps, robots.txt, and auto-injection.
+ */
+// SEO metadata generation
+export { generateSEOMetadata, generateSEO, generateOpenGraphTags, generateTwitterCardTags, } from './generator.js';
+// Sitemap generation
+export { generateSitemap, generateSitemapEntry, generateSitemapXml, generateSitemapIndexXml, } from './sitemap.js';
+// Robots.txt generation
+export { generateRobotsTxt, generateRobotsTxtFromConfig } from './robots.js';
+// Auto-injection
+export { autoInjectSEO, shouldAutoInject } from './auto-inject.js';
+// SEO utilities
+export { escapeHtml, generateRobotsContent, validateSEOMetadata, detectExistingSEOTags, normalizeUrlPath, resolveAbsoluteUrl, isValidUrl, } from './utils/index.js';

package/dist/seo/robots.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Robots.txt generation utilities for Stati
+ * @module seo/robots
+ */
+import type { RobotsTxtConfig } from '../types/config.js';
+/**
+ * User agent rule entry for robots.txt
+ */
+export interface UserAgentRule {
+    /** User agent name (e.g., 'Googlebot', '*') */
+    userAgent: string;
+    /** Paths to allow */
+    allow?: string[];
+    /** Paths to disallow */
+    disallow?: string[];
+    /** Crawl delay in seconds */
+    crawlDelay?: number;
+}
+/**
+ * Options for generating robots.txt content
+ */
+export interface RobotsTxtOptions {
+    /** User agent rules */
+    rules?: UserAgentRule[];
+    /** Sitemap URLs to include */
+    sitemaps?: string[];
+    /** Additional custom directives */
+    custom?: string[];
+    /** Site base URL for resolving sitemap paths */
+    siteUrl?: string;
+}
+/**
+ * Generates robots.txt content from options
+ * @param options - Robots.txt generation options
+ * @returns Generated robots.txt content
+ *
+ * @example
+ * ```typescript
+ * const content = generateRobotsTxt({
+ *   rules: [
+ *     {
+ *       userAgent: 'Googlebot',
+ *       allow: ['/'],
+ *       crawlDelay: 1
+ *     },
+ *     {
+ *       userAgent: '*',
+ *       disallow: ['/admin/', '/api/']
+ *     }
+ *   ],
+ *   sitemaps: ['https://example.com/sitemap.xml'],
+ *   custom: ['# Custom comment']
+ * });
+ * ```
+ */
+export declare function generateRobotsTxt(options?: RobotsTxtOptions): string;
+/**
+ * Converts Stati RobotsTxtConfig to RobotsTxtOptions
+ * @param config - Stati robots.txt configuration
+ * @param siteUrl - Site base URL
+ * @returns Robots.txt generation options
+ */
+export declare function configToOptions(config: RobotsTxtConfig, siteUrl?: string): RobotsTxtOptions;
+/**
+ * Generates robots.txt content from Stati configuration
+ * @param config - Stati robots.txt configuration
+ * @param siteUrl - Site base URL for resolving sitemap paths
+ * @returns Generated robots.txt content
+ *
+ * @example
+ * ```typescript
+ * const content = generateRobotsTxtFromConfig(
+ *   {
+ *     rules: [
+ *       { userAgent: '*', allow: ['/'] }
+ *     ],
+ *     sitemaps: ['/sitemap.xml']
+ *   },
+ *   'https://example.com'
+ * );
+ * ```
+ */
+export declare function generateRobotsTxtFromConfig(config: RobotsTxtConfig, siteUrl?: string): string;
+//# sourceMappingURL=robots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"robots.d.ts","sourceRoot":"","sources":["../../src/seo/robots.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG1D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uBAAuB;IACvB,KAAK,CAAC,EAAE,aAAa,EAAE,CAAC;IACxB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,mCAAmC;IACnC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAcD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,gBAAqB,GAAG,MAAM,CA2CxE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAqE3F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAG7F"}

package/dist/seo/robots.js

@@ -0,0 +1,165 @@
+/**
+ * Robots.txt generation utilities for Stati
+ * @module seo/robots
+ */
+import { isValidUrl, resolveAbsoluteUrl, normalizeUrlPath } from './utils/index.js';
+/**
+ * Default robots.txt configuration (allow all)
+ */
+const DEFAULT_ROBOTS_CONFIG = {
+    rules: [
+        {
+            userAgent: '*',
+            allow: ['/'],
+        },
+    ],
+};
+/**
+ * Generates robots.txt content from options
+ * @param options - Robots.txt generation options
+ * @returns Generated robots.txt content
+ *
+ * @example
+ * ```typescript
+ * const content = generateRobotsTxt({
+ *   rules: [
+ *     {
+ *       userAgent: 'Googlebot',
+ *       allow: ['/'],
+ *       crawlDelay: 1
+ *     },
+ *     {
+ *       userAgent: '*',
+ *       disallow: ['/admin/', '/api/']
+ *     }
+ *   ],
+ *   sitemaps: ['https://example.com/sitemap.xml'],
+ *   custom: ['# Custom comment']
+ * });
+ * ```
+ */
+export function generateRobotsTxt(options = {}) {
+    const lines = [];
+    const { rules = [], sitemaps = [], custom = [], siteUrl } = options;
+    // Use default rules if none provided
+    const effectiveRules = rules.length > 0 ? rules : (DEFAULT_ROBOTS_CONFIG.rules ?? []);
+    // Generate rules
+    effectiveRules.forEach((rule) => {
+        lines.push(`User-agent: ${rule.userAgent}`);
+        if (rule.allow) {
+            rule.allow.forEach((path) => lines.push(`Allow: ${normalizeUrlPath(path)}`));
+        }
+        if (rule.disallow) {
+            rule.disallow.forEach((path) => lines.push(`Disallow: ${normalizeUrlPath(path)}`));
+        }
+        if (typeof rule.crawlDelay === 'number' && rule.crawlDelay > 0) {
+            lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+        }
+        lines.push(''); // Add a blank line after each rule
+    });
+    // Add sitemaps
+    if (sitemaps.length > 0) {
+        sitemaps.forEach((sitemap) => {
+            // Ensure sitemap URL is absolute
+            const sitemapUrl = siteUrl && !isValidUrl(sitemap) ? resolveAbsoluteUrl(sitemap, siteUrl) : sitemap;
+            lines.push(`Sitemap: ${sitemapUrl}`);
+        });
+        lines.push(''); // Add a blank line
+    }
+    // Add custom directives
+    if (custom.length > 0) {
+        lines.push(...custom, '');
+    }
+    return lines.join('\n');
+}
+/**
+ * Converts Stati RobotsTxtConfig to RobotsTxtOptions
+ * @param config - Stati robots.txt configuration
+ * @param siteUrl - Site base URL
+ * @returns Robots.txt generation options
+ */
+export function configToOptions(config, siteUrl) {
+    const options = {};
+    // Add siteUrl if provided
+    if (siteUrl !== undefined) {
+        options.siteUrl = siteUrl;
+    }
+    const rules = [];
+    // Convert user agent specific rules
+    if (config.userAgents && config.userAgents.length > 0) {
+        for (const ua of config.userAgents) {
+            const rule = {
+                userAgent: ua.userAgent,
+            };
+            if (ua.allow !== undefined) {
+                rule.allow = ua.allow;
+            }
+            if (ua.disallow !== undefined) {
+                rule.disallow = ua.disallow;
+            }
+            rules.push(rule);
+        }
+    }
+    // Add global rules as wildcard user agent
+    if (config.allow || config.disallow || config.crawlDelay !== undefined) {
+        const rule = {
+            userAgent: '*',
+        };
+        if (config.allow !== undefined) {
+            rule.allow = config.allow;
+        }
+        if (config.disallow !== undefined) {
+            rule.disallow = config.disallow;
+        }
+        if (config.crawlDelay !== undefined) {
+            rule.crawlDelay = config.crawlDelay;
+        }
+        rules.push(rule);
+    }
+    if (rules.length > 0) {
+        options.rules = rules;
+    }
+    // Handle sitemap configuration
+    const sitemaps = [];
+    if (config.sitemap) {
+        if (typeof config.sitemap === 'string') {
+            // Explicit sitemap URL
+            sitemaps.push(config.sitemap);
+        }
+        else if (config.sitemap === true) {
+            // Auto-include sitemap.xml
+            sitemaps.push('/sitemap.xml');
+        }
+    }
+    if (sitemaps.length > 0) {
+        options.sitemaps = sitemaps;
+    }
+    // Add custom directives
+    if (config.customLines && config.customLines.length > 0) {
+        options.custom = config.customLines;
+    }
+    return options;
+}
+/**
+ * Generates robots.txt content from Stati configuration
+ * @param config - Stati robots.txt configuration
+ * @param siteUrl - Site base URL for resolving sitemap paths
+ * @returns Generated robots.txt content
+ *
+ * @example
+ * ```typescript
+ * const content = generateRobotsTxtFromConfig(
+ *   {
+ *     rules: [
+ *       { userAgent: '*', allow: ['/'] }
+ *     ],
+ *     sitemaps: ['/sitemap.xml']
+ *   },
+ *   'https://example.com'
+ * );
+ * ```
+ */
+export function generateRobotsTxtFromConfig(config, siteUrl) {
+    const options = configToOptions(config, siteUrl);
+    return generateRobotsTxt(options);
+}