@stati/core 1.10.2 → 1.11.0

package/dist/rss/generator.js

@@ -0,0 +1,331 @@
+/**
+ * RSS feed generation utilities for Stati
+ * @module rss/generator
+ */
+import { escapeHtml } from '../seo/utils/index.js';
+import { filterByPatterns } from './utils/index.js';
+/**
+ * Formats a date for RSS pubDate field (RFC 822)
+ * @param date - Date to format
+ * @returns RFC 822 formatted date string
+ */
+function formatRSSDate(date) {
+    return date.toUTCString();
+}
+/**
+ * Converts a date string or Date object to RFC 822 format
+ * @param dateInput - Date string or Date object
+ * @returns RFC 822 formatted date string or undefined if invalid
+ */
+function parseAndFormatDate(dateInput) {
+    if (!dateInput)
+        return undefined;
+    let date;
+    if (typeof dateInput === 'string') {
+        date = new Date(dateInput);
+    }
+    else {
+        date = dateInput;
+    }
+    if (isNaN(date.getTime())) {
+        return undefined;
+    }
+    return formatRSSDate(date);
+}
+/**
+ * Filters pages based on feed configuration
+ * @param pages - All pages
+ * @param feedConfig - Feed configuration
+ * @returns Filtered pages
+ */
+function filterPages(pages, feedConfig) {
+    const options = {};
+    if (feedConfig.contentPatterns) {
+        options.includePatterns = feedConfig.contentPatterns;
+    }
+    if (feedConfig.excludePatterns) {
+        options.excludePatterns = feedConfig.excludePatterns;
+    }
+    let filtered = filterByPatterns(pages, (page) => page.sourcePath, options);
+    // Apply custom filter function if provided
+    if (feedConfig.filter) {
+        filtered = filtered.filter(feedConfig.filter);
+    }
+    return filtered;
+}
+/**
+ * Helper to get date value from page for sorting
+ * @param page - Page to get date from
+ * @returns Date value or undefined
+ */
+function getPageDate(page) {
+    return page.frontMatter.publishedAt || page.frontMatter.date;
+}
+/**
+ * Sorts pages based on feed configuration
+ * @param pages - Pages to sort
+ * @param feedConfig - Feed configuration
+ * @returns Sorted pages
+ */
+function sortPages(pages, feedConfig) {
+    const sorted = [...pages];
+    const sortBy = feedConfig.sortBy || 'date-desc';
+    if (sortBy === 'custom' && feedConfig.sortFn) {
+        return sorted.sort(feedConfig.sortFn);
+    }
+    return sorted.sort((a, b) => {
+        switch (sortBy) {
+            case 'date-desc':
+            case 'date-asc': {
+                const dateA = getPageDate(a);
+                const dateB = getPageDate(b);
+                if (!dateA && !dateB)
+                    return 0;
+                if (!dateA)
+                    return 1;
+                if (!dateB)
+                    return -1;
+                const comparison = new Date(dateA).getTime() - new Date(dateB).getTime();
+                return sortBy === 'date-asc' ? comparison : -comparison;
+            }
+            case 'title-asc':
+            case 'title-desc': {
+                const titleA = (a.frontMatter.title || '').toLowerCase();
+                const titleB = (b.frontMatter.title || '').toLowerCase();
+                const comparison = titleA.localeCompare(titleB);
+                return sortBy === 'title-asc' ? comparison : -comparison;
+            }
+            default:
+                return 0;
+        }
+    });
+}
+/**
+ * Type guard to ensure we have a valid record-like object
+ * @param value - Value to check
+ * @returns True if value is a non-null object
+ */
+function isValidRecord(value) {
+    return value !== null && value !== undefined && typeof value === 'object';
+}
+/**
+ * Gets a value from page using field mapping with improved type safety
+ * @param page - Page to extract value from
+ * @param mapping - Field mapping (property name or function)
+ * @param defaultProp - Default property name to use
+ * @param logger - Logger instance for warnings
+ * @returns Extracted value or undefined
+ */
+function getFieldValue(page, mapping, defaultProp, logger) {
+    if (typeof mapping === 'function') {
+        try {
+            return mapping(page);
+        }
+        catch (error) {
+            // Log error but don't crash - return undefined for invalid mappings
+            if (logger) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.warning(`Field mapping function failed for page ${page.slug}: ${errorMessage}`);
+            }
+            return undefined;
+        }
+    }
+    const prop = mapping || defaultProp;
+    if (!prop)
+        return undefined;
+    // Type-safe access to frontMatter properties using type guard
+    // FrontMatter interface allows index signature for custom properties
+    if (!isValidRecord(page.frontMatter)) {
+        return undefined;
+    }
+    const value = page.frontMatter[prop];
+    // Return value with proper type checking
+    return value !== undefined && value !== null ? value : undefined;
+}
+/**
+ * Builds the absolute URL for a page
+ * @param page - Page to build URL for
+ * @param config - Stati configuration
+ * @returns Absolute URL
+ */
+function buildPageUrl(page, config) {
+    const baseUrl = config.site.baseUrl.replace(/\/$/, '');
+    const pageUrl = page.url.startsWith('/') ? page.url : '/' + page.url;
+    return baseUrl + pageUrl;
+}
+/**
+ * Generates RSS XML for a single feed
+ * @param pages - All pages in the site
+ * @param config - Stati configuration
+ * @param feedConfig - Feed configuration
+ * @param logger - Logger instance for warnings (optional)
+ * @returns RSS generation result
+ */
+export function generateRSSFeed(pages, config, feedConfig, logger) {
+    // Filter and sort pages
+    let feedPages = sortPages(filterPages(pages, feedConfig), feedConfig);
+    // Limit to maxItems if specified
+    if (feedConfig.maxItems && feedConfig.maxItems > 0) {
+        feedPages = feedPages.slice(0, feedConfig.maxItems);
+    }
+    // Build feed metadata
+    const feedLink = feedConfig.link || config.site.baseUrl;
+    const feedTitle = feedConfig.title;
+    const feedDescription = feedConfig.description;
+    // Start building XML
+    const xmlLines = [];
+    xmlLines.push('<?xml version="1.0" encoding="UTF-8"?>');
+    // Build namespace attributes
+    const namespaces = feedConfig.namespaces || {};
+    const nsAttrs = Object.entries(namespaces)
+        .map(([prefix, uri]) => `xmlns:${prefix}="${escapeHtml(uri)}"`)
+        .join(' ');
+    xmlLines.push(`<rss version="2.0"${nsAttrs ? ' ' + nsAttrs : ''}>`);
+    xmlLines.push('  <channel>');
+    xmlLines.push(`    <title>${escapeHtml(feedTitle)}</title>`);
+    xmlLines.push(`    <link>${escapeHtml(feedLink)}</link>`);
+    xmlLines.push(`    <description>${escapeHtml(feedDescription)}</description>`);
+    // Optional channel elements
+    if (feedConfig.language) {
+        xmlLines.push(`    <language>${escapeHtml(feedConfig.language)}</language>`);
+    }
+    if (feedConfig.copyright) {
+        xmlLines.push(`    <copyright>${escapeHtml(feedConfig.copyright)}</copyright>`);
+    }
+    if (feedConfig.managingEditor) {
+        xmlLines.push(`    <managingEditor>${escapeHtml(feedConfig.managingEditor)}</managingEditor>`);
+    }
+    if (feedConfig.webMaster) {
+        xmlLines.push(`    <webMaster>${escapeHtml(feedConfig.webMaster)}</webMaster>`);
+    }
+    // Publication date and last build date (use same timestamp for consistency)
+    const buildDate = new Date();
+    xmlLines.push(`    <pubDate>${formatRSSDate(buildDate)}</pubDate>`);
+    // Last build date
+    xmlLines.push(`    <lastBuildDate>${formatRSSDate(buildDate)}</lastBuildDate>`);
+    if (feedConfig.category) {
+        xmlLines.push(`    <category>${escapeHtml(feedConfig.category)}</category>`);
+    }
+    // Generator
+    xmlLines.push(`    <generator>Stati Static Site Generator</generator>`);
+    if (feedConfig.ttl) {
+        xmlLines.push(`    <ttl>${feedConfig.ttl}</ttl>`);
+    }
+    // Image
+    if (feedConfig.image) {
+        xmlLines.push(`    <image>`);
+        xmlLines.push(`      <url>${escapeHtml(feedConfig.image.url)}</url>`);
+        xmlLines.push(`      <title>${escapeHtml(feedConfig.image.title)}</title>`);
+        xmlLines.push(`      <link>${escapeHtml(feedConfig.image.link)}</link>`);
+        if (feedConfig.image.width) {
+            xmlLines.push(`      <width>${feedConfig.image.width}</width>`);
+        }
+        if (feedConfig.image.height) {
+            xmlLines.push(`      <height>${feedConfig.image.height}</height>`);
+        }
+        xmlLines.push(`    </image>`);
+    }
+    // Add items
+    const itemMapping = feedConfig.itemMapping || {};
+    for (const page of feedPages) {
+        xmlLines.push(`    <item>`);
+        // Title
+        const title = getFieldValue(page, itemMapping.title, 'title', logger);
+        if (title) {
+            xmlLines.push(`      <title>${escapeHtml(title)}</title>`);
+        }
+        // Link
+        let link;
+        if (itemMapping.link) {
+            link = itemMapping.link(page, config);
+        }
+        else {
+            link = buildPageUrl(page, config);
+        }
+        xmlLines.push(`      <link>${escapeHtml(link)}</link>`);
+        // Description (or full content)
+        if (itemMapping.includeContent && page.content) {
+            xmlLines.push(`      <description><![CDATA[${page.content}]]></description>`);
+        }
+        else {
+            const description = getFieldValue(page, itemMapping.description, 'description', logger);
+            if (description) {
+                xmlLines.push(`      <description>${escapeHtml(description)}</description>`);
+            }
+        }
+        // Pub date
+        const pubDate = getFieldValue(page, itemMapping.pubDate, 'publishedAt', logger) ||
+            getFieldValue(page, itemMapping.pubDate, 'date', logger);
+        const formattedPubDate = parseAndFormatDate(pubDate);
+        if (formattedPubDate) {
+            xmlLines.push(`      <pubDate>${formattedPubDate}</pubDate>`);
+        }
+        // Author
+        const author = getFieldValue(page, itemMapping.author, 'author', logger);
+        if (author) {
+            xmlLines.push(`      <author>${escapeHtml(author)}</author>`);
+        }
+        // Category/categories
+        const category = getFieldValue(page, itemMapping.category, 'tags', logger);
+        if (category) {
+            const categories = Array.isArray(category) ? category : [category];
+            for (const cat of categories) {
+                xmlLines.push(`      <category>${escapeHtml(cat)}</category>`);
+            }
+        }
+        // GUID
+        let guid;
+        if (itemMapping.guid) {
+            guid = itemMapping.guid(page, config);
+        }
+        else {
+            guid = link;
+        }
+        xmlLines.push(`      <guid isPermaLink="true">${escapeHtml(guid)}</guid>`);
+        // Enclosure
+        if (feedConfig.enclosure) {
+            const enclosure = feedConfig.enclosure(page);
+            if (enclosure) {
+                xmlLines.push(`      <enclosure url="${escapeHtml(enclosure.url)}" length="${enclosure.length}" type="${escapeHtml(enclosure.type)}" />`);
+            }
+        }
+        // Custom elements
+        if (feedConfig.customItemElements) {
+            const customElements = feedConfig.customItemElements(page);
+            for (const [key, value] of Object.entries(customElements)) {
+                if (value !== undefined && value !== null) {
+                    xmlLines.push(`      <${key}>${escapeHtml(String(value))}</${key}>`);
+                }
+            }
+        }
+        xmlLines.push(`    </item>`);
+    }
+    xmlLines.push('  </channel>');
+    xmlLines.push('</rss>');
+    const xml = xmlLines.join('\n');
+    return {
+        filename: feedConfig.filename,
+        itemCount: feedPages.length,
+        sizeInBytes: Buffer.byteLength(xml, 'utf8'),
+        xml,
+    };
+}
+/**
+ * Generates all RSS feeds configured in the site
+ * @param pages - All pages in the site
+ * @param config - Stati configuration
+ * @param logger - Logger instance for warnings (optional)
+ * @returns Array of RSS generation results
+ */
+export function generateRSSFeeds(pages, config, logger) {
+    const rssConfig = config.rss;
+    if (!rssConfig || !rssConfig.enabled || !rssConfig.feeds) {
+        return [];
+    }
+    const results = [];
+    for (const feedConfig of rssConfig.feeds) {
+        const result = generateRSSFeed(pages, config, feedConfig, logger);
+        results.push(result);
+    }
+    return results;
+}

package/dist/rss/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * RSS feed generation module
+ * @module rss
+ */
+export { generateRSSFeed, generateRSSFeeds } from './generator.js';
+export { validateRSSConfig, validateRSSFeedConfig } from './validation.js';
+export type { RSSValidationResult } from './validation.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rss/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/rss/index.js

@@ -0,0 +1,6 @@
+/**
+ * RSS feed generation module
+ * @module rss
+ */
+export { generateRSSFeed, generateRSSFeeds } from './generator.js';
+export { validateRSSConfig, validateRSSFeedConfig } from './validation.js';

package/dist/rss/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RSS utilities barrel export
+ * @module rss/utils
+ */
+export { matchesAnyPattern, urlMatchesAnyPattern, filterByPatterns } from './pattern-matching.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/rss/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rss/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/rss/utils/index.js

@@ -0,0 +1,5 @@
+/**
+ * RSS utilities barrel export
+ * @module rss/utils
+ */
+export { matchesAnyPattern, urlMatchesAnyPattern, filterByPatterns } from './pattern-matching.js';

package/dist/rss/utils/pattern-matching.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared pattern matching utilities for Stati
+ * Provides glob pattern matching functionality used across RSS, sitemap, and other modules
+ * @module utils/pattern-matching
+ */
+/**
+ * Checks if a path matches any of the given glob patterns
+ * @param path - Path to check (will be normalized to forward slashes)
+ * @param patterns - Array of glob patterns
+ * @param allowPrefix - If true, also match if path starts with pattern (for non-glob patterns)
+ * @returns true if path matches any pattern
+ */
+export declare function matchesAnyPattern(path: string, patterns: string[], allowPrefix?: boolean): boolean;
+/**
+ * Checks if a path matches any of the given glob patterns (URL-based)
+ * This is a convenience wrapper for URL-based matching
+ * @param url - URL to check
+ * @param patterns - Array of glob patterns
+ * @returns true if URL matches any pattern
+ */
+export declare function urlMatchesAnyPattern(url: string, patterns: string[]): boolean;
+/**
+ * Filters an array of items based on include and exclude patterns
+ * @param items - Items to filter
+ * @param getPath - Function to extract path from item
+ * @param options - Filter options
+ * @returns Filtered items
+ */
+export declare function filterByPatterns<T>(items: T[], getPath: (item: T) => string, options?: {
+    includePatterns?: string[];
+    excludePatterns?: string[];
+}): T[];
+//# sourceMappingURL=pattern-matching.d.ts.map

package/dist/rss/utils/pattern-matching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-matching.d.ts","sourceRoot":"","sources":["../../../src/rss/utils/pattern-matching.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,WAAW,UAAO,GAAG,OAAO,CAgD/F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAE7E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC5B,OAAO,GAAE;IACP,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,GACL,CAAC,EAAE,CAkBL"}

package/dist/rss/utils/pattern-matching.js

@@ -0,0 +1,87 @@
+/**
+ * Shared pattern matching utilities for Stati
+ * Provides glob pattern matching functionality used across RSS, sitemap, and other modules
+ * @module utils/pattern-matching
+ */
+import { globToRegex } from '../../core/utils/index.js';
+/**
+ * Checks if a path matches any of the given glob patterns
+ * @param path - Path to check (will be normalized to forward slashes)
+ * @param patterns - Array of glob patterns
+ * @param allowPrefix - If true, also match if path starts with pattern (for non-glob patterns)
+ * @returns true if path matches any pattern
+ */
+export function matchesAnyPattern(path, patterns, allowPrefix = true) {
+    if (patterns.length === 0) {
+        return false;
+    }
+    // Normalize path to use forward slashes
+    const normalizedPath = path.replace(/\\/g, '/');
+    for (const pattern of patterns) {
+        const normalizedPattern = pattern.replace(/\\/g, '/');
+        // Check if pattern is a glob pattern
+        if (normalizedPattern.includes('*') || normalizedPattern.includes('?')) {
+            const regex = globToRegex(normalizedPattern);
+            if (regex.test(normalizedPath)) {
+                return true;
+            }
+        }
+        else {
+            // For non-glob patterns, check exact match first
+            if (normalizedPath === normalizedPattern) {
+                return true;
+            }
+            // For prefix matching with path boundaries
+            if (allowPrefix) {
+                // Special case: root pattern "/" should ONLY match "/" exactly
+                if (normalizedPattern === '/') {
+                    continue; // Already checked exact match above, skip prefix matching
+                }
+                // For patterns ending with "/", they are explicitly prefix patterns
+                if (normalizedPattern.endsWith('/')) {
+                    if (normalizedPath.startsWith(normalizedPattern)) {
+                        return true;
+                    }
+                }
+                else {
+                    // For other patterns, match if:
+                    // 1. Path starts with pattern followed by "/"
+                    // This ensures "/api" matches "/api/foo" but not "/apitest"
+                    if (normalizedPath.startsWith(normalizedPattern + '/')) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Checks if a path matches any of the given glob patterns (URL-based)
+ * This is a convenience wrapper for URL-based matching
+ * @param url - URL to check
+ * @param patterns - Array of glob patterns
+ * @returns true if URL matches any pattern
+ */
+export function urlMatchesAnyPattern(url, patterns) {
+    return matchesAnyPattern(url, patterns, true);
+}
+/**
+ * Filters an array of items based on include and exclude patterns
+ * @param items - Items to filter
+ * @param getPath - Function to extract path from item
+ * @param options - Filter options
+ * @returns Filtered items
+ */
+export function filterByPatterns(items, getPath, options = {}) {
+    let filtered = [...items];
+    // Apply include patterns first (if specified)
+    if (options.includePatterns && options.includePatterns.length > 0) {
+        filtered = filtered.filter((item) => matchesAnyPattern(getPath(item), options.includePatterns, true));
+    }
+    // Apply exclude patterns
+    if (options.excludePatterns && options.excludePatterns.length > 0) {
+        filtered = filtered.filter((item) => !matchesAnyPattern(getPath(item), options.excludePatterns, true));
+    }
+    return filtered;
+}

package/dist/rss/validation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * RSS feed validation utilities
+ * @module rss/validation
+ */
+import type { RSSFeedConfig, RSSConfig } from '../types/rss.js';
+/**
+ * Validation result for RSS configuration
+ */
+export interface RSSValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Array of validation errors (empty if valid) */
+    errors: string[];
+    /** Array of validation warnings (non-critical issues) */
+    warnings: string[];
+}
+/**
+ * Validates a single RSS feed configuration
+ * @param feedConfig - Feed configuration to validate
+ * @param feedIndex - Index of feed in config array (for error messages)
+ * @returns Validation result
+ */
+export declare function validateRSSFeedConfig(feedConfig: RSSFeedConfig, feedIndex?: number): RSSValidationResult;
+/**
+ * Validates RSS configuration
+ * @param rssConfig - RSS configuration to validate
+ * @returns Validation result
+ */
+export declare function validateRSSConfig(rssConfig: RSSConfig | undefined): RSSValidationResult;
+//# sourceMappingURL=validation.d.ts.map

package/dist/rss/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/rss/validation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IACf,kDAAkD;IAClD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,yDAAyD;IACzD,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,aAAa,EACzB,SAAS,SAAI,GACZ,mBAAmB,CA0FrB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,mBAAmB,CAuCvF"}

package/dist/rss/validation.js

@@ -0,0 +1,124 @@
+/**
+ * RSS feed validation utilities
+ * @module rss/validation
+ */
+/**
+ * Validates a single RSS feed configuration
+ * @param feedConfig - Feed configuration to validate
+ * @param feedIndex - Index of feed in config array (for error messages)
+ * @returns Validation result
+ */
+export function validateRSSFeedConfig(feedConfig, feedIndex = 0) {
+    const errors = [];
+    const warnings = [];
+    // Required fields
+    if (!feedConfig.filename) {
+        errors.push(`Feed ${feedIndex}: 'filename' is required`);
+    }
+    else if (!feedConfig.filename.endsWith('.xml')) {
+        warnings.push(`Feed ${feedIndex}: filename '${feedConfig.filename}' should end with .xml`);
+    }
+    if (!feedConfig.title || feedConfig.title.trim() === '') {
+        errors.push(`Feed ${feedIndex}: 'title' is required and cannot be empty`);
+    }
+    if (!feedConfig.description || feedConfig.description.trim() === '') {
+        errors.push(`Feed ${feedIndex}: 'description' is required and cannot be empty`);
+    }
+    // Validate optional fields
+    if (feedConfig.ttl !== undefined) {
+        if (typeof feedConfig.ttl !== 'number' || feedConfig.ttl < 0) {
+            errors.push(`Feed ${feedIndex}: 'ttl' must be a non-negative number`);
+        }
+        else if (feedConfig.ttl === 0) {
+            warnings.push(`Feed ${feedIndex}: ttl is 0, which means feed should not be cached`);
+        }
+    }
+    if (feedConfig.maxItems !== undefined) {
+        if (typeof feedConfig.maxItems !== 'number' || feedConfig.maxItems < 1) {
+            errors.push(`Feed ${feedIndex}: 'maxItems' must be a positive number`);
+        }
+    }
+    // Validate sort configuration
+    if (feedConfig.sortBy === 'custom' && !feedConfig.sortFn) {
+        errors.push(`Feed ${feedIndex}: 'sortFn' is required when sortBy is 'custom'`);
+    }
+    const validSortOptions = ['date-desc', 'date-asc', 'title-asc', 'title-desc', 'custom'];
+    if (feedConfig.sortBy && !validSortOptions.includes(feedConfig.sortBy)) {
+        errors.push(`Feed ${feedIndex}: 'sortBy' must be one of: ${validSortOptions.join(', ')}`);
+    }
+    // Validate image configuration
+    if (feedConfig.image) {
+        if (!feedConfig.image.url) {
+            errors.push(`Feed ${feedIndex}: image.url is required when image is specified`);
+        }
+        if (!feedConfig.image.title) {
+            errors.push(`Feed ${feedIndex}: image.title is required when image is specified`);
+        }
+        if (!feedConfig.image.link) {
+            errors.push(`Feed ${feedIndex}: image.link is required when image is specified`);
+        }
+        if (feedConfig.image.width !== undefined && feedConfig.image.width > 144) {
+            warnings.push(`Feed ${feedIndex}: image width ${feedConfig.image.width} exceeds recommended maximum of 144 pixels`);
+        }
+        if (feedConfig.image.height !== undefined && feedConfig.image.height > 400) {
+            warnings.push(`Feed ${feedIndex}: image height ${feedConfig.image.height} exceeds recommended maximum of 400 pixels`);
+        }
+    }
+    // Validate email formats
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+/;
+    if (feedConfig.managingEditor && !emailPattern.test(feedConfig.managingEditor)) {
+        warnings.push(`Feed ${feedIndex}: managingEditor should start with a valid email address (format: 'email@example.com (Name)')`);
+    }
+    if (feedConfig.webMaster && !emailPattern.test(feedConfig.webMaster)) {
+        warnings.push(`Feed ${feedIndex}: webMaster should start with a valid email address (format: 'email@example.com (Name)')`);
+    }
+    // Validate patterns
+    if (feedConfig.contentPatterns && feedConfig.contentPatterns.length === 0) {
+        warnings.push(`Feed ${feedIndex}: contentPatterns is empty - feed may not include any content`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validates RSS configuration
+ * @param rssConfig - RSS configuration to validate
+ * @returns Validation result
+ */
+export function validateRSSConfig(rssConfig) {
+    const errors = [];
+    const warnings = [];
+    if (!rssConfig) {
+        return { valid: true, errors: [], warnings: ['RSS configuration is not defined'] };
+    }
+    if (!rssConfig.enabled) {
+        return { valid: true, errors: [], warnings: ['RSS feed generation is disabled'] };
+    }
+    if (!rssConfig.feeds || rssConfig.feeds.length === 0) {
+        errors.push('At least one feed configuration is required when RSS is enabled');
+        return { valid: false, errors, warnings };
+    }
+    // Validate each feed
+    const feedFilenames = new Set();
+    rssConfig.feeds.forEach((feedConfig, index) => {
+        const result = validateRSSFeedConfig(feedConfig, index);
+        errors.push(...result.errors);
+        warnings.push(...result.warnings);
+        // Check for duplicate filenames
+        if (feedConfig.filename) {
+            if (feedFilenames.has(feedConfig.filename)) {
+                errors.push(`Duplicate filename '${feedConfig.filename}' found in feed ${index}`);
+            }
+            else {
+                feedFilenames.add(feedConfig.filename);
+            }
+        }
+    });
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"sitemap.d.ts","sourceRoot":"","sources":["../../src/seo/sitemap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAEb,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAqJtD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,aAAa,GAC3B,YAAY,GAAG,IAAI,CA4ErB;AA2BD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAUlE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAatF;AAoBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,EAAE,EAClB,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CA8CzB"}
+{"version":3,"file":"sitemap.d.ts","sourceRoot":"","sources":["../../src/seo/sitemap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAEb,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAoGtD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,aAAa,GAC3B,YAAY,GAAG,IAAI,CA4ErB;AA2BD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAUlE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAatF;AAoBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,EAAE,EAClB,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CA8CzB"}