@stati/core 1.10.2 → 1.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/core/build.ts"],"names":[],"mappings":"AAyCA,OAAO,KAAK,EAEV,UAAU,EACV,MAAM,EAKP,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,CAW3E"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/core/build.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAEV,UAAU,EACV,MAAM,EAKP,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,CAW3E"}

package/dist/core/build.js

@@ -8,6 +8,8 @@ import { createTemplateEngine, renderPage } from './templates.js';
 import { buildNavigation } from './navigation.js';
 import { loadCacheManifest, saveCacheManifest, shouldRebuildPage, createCacheEntry, updateCacheEntry, withBuildLock, computeNavigationHash, } from './isg/index.js';
 import { generateSitemap, generateRobotsTxtFromConfig, autoInjectSEO, } from '../seo/index.js';
+import { generateRSSFeeds, validateRSSConfig } from '../rss/index.js';
+import { getEnv } from '../env.js';
 /**
  * Recursively calculates the total size of a directory in bytes.
  * Used for build statistics.
@@ -413,8 +415,10 @@ async function buildInternal(options = {}) {
     // Copy static assets and count them
     let assetsCount = 0;
     assetsCount = await copyStaticAssets(config, outDir, logger);
-    // Generate sitemap if enabled
-    if (config.sitemap?.enabled) {
+    // Get current environment
+    const currentEnv = getEnv();
+    // Generate sitemap if enabled (only in production mode)
+    if (config.sitemap?.enabled && currentEnv === 'production') {
         console.log(); // Add spacing before sitemap generation
         logger.info('Generating sitemap...');
         const sitemapResult = generateSitemap(pages, config, config.sitemap);
@@ -430,14 +434,58 @@ async function buildInternal(options = {}) {
             logger.success(`Generated sitemap with ${sitemapResult.entryCount} entries`);
         }
     }
-    // Generate robots.txt if enabled
-    if (config.robots?.enabled) {
+    // Generate robots.txt if enabled (only in production mode)
+    if (config.robots?.enabled && currentEnv === 'production') {
         console.log(); // Add spacing before robots.txt generation
         logger.info('Generating robots.txt...');
         const robotsContent = generateRobotsTxtFromConfig(config.robots, config.site.baseUrl);
         await writeFile(join(outDir, 'robots.txt'), robotsContent);
         logger.success('Generated robots.txt');
     }
+    // Generate RSS feeds if enabled (only in production mode)
+    if (config.rss?.enabled && currentEnv === 'production') {
+        console.log(); // Add spacing before RSS generation
+        logger.info('Generating RSS feeds...');
+        try {
+            // Validate RSS configuration before generating
+            const validationResult = validateRSSConfig(config.rss);
+            if (!validationResult.valid) {
+                logger.error('RSS configuration validation failed:');
+                validationResult.errors.forEach((error) => logger.error(`  - ${error}`));
+                if (validationResult.warnings.length > 0) {
+                    validationResult.warnings.forEach((warning) => logger.warning(`  - ${warning}`));
+                }
+            }
+            else {
+                // Log warnings if any
+                if (validationResult.warnings.length > 0) {
+                    validationResult.warnings.forEach((warning) => logger.warning(warning));
+                }
+                // Validate pages array before generating feeds
+                if (pages.length === 0) {
+                    logger.warning('No pages found to include in RSS feeds');
+                }
+                else {
+                    const rssResults = generateRSSFeeds(pages, config, logger);
+                    if (rssResults && rssResults.length > 0) {
+                        for (const result of rssResults) {
+                            await writeFile(join(outDir, result.filename), result.xml);
+                            logger.success(`Generated ${result.filename} with ${result.itemCount} items (${(result.sizeInBytes / 1024).toFixed(2)} KB)`);
+                        }
+                        logger.success(`Generated ${rssResults.length} RSS feed${rssResults.length > 1 ? 's' : ''}`);
+                    }
+                    else {
+                        logger.info('No RSS feeds generated (no matching pages found)');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred during RSS generation';
+            logger.error(`Failed to generate RSS feeds: ${errorMessage}`);
+            // Don't throw - allow build to continue even if RSS generation fails
+        }
+    }
     // Run afterAll hook
     if (config.hooks?.afterAll) {
         await config.hooks.afterAll({ config, pages });

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

@@ -1 +1 @@
-{"version":3,"file":"invalidate.d.ts","sourceRoot":"","sources":["../../src/core/invalidate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAkC9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAkC9F;AAuLD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAoD5E"}
+{"version":3,"file":"invalidate.d.ts","sourceRoot":"","sources":["../../src/core/invalidate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAkC9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAkC9F;AAuED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAoD5E"}

package/dist/core/invalidate.js

@@ -1,5 +1,5 @@
 import { loadCacheManifest, saveCacheManifest } from './isg/index.js';
-import { resolveCacheDir } from './utils/index.js';
+import { resolveCacheDir, matchesGlob as matchesGlobPattern } from './utils/index.js';
 /**
  * Parses an invalidation query string into individual query terms.
  * Supports space-separated values and quoted strings.
@@ -77,8 +77,8 @@ export function matchesInvalidationTerm(entry, path, term) {
                 // Support both exact path match and prefix match
                 return path === value || path.startsWith(value);
             case 'glob':
-                // Simple glob pattern matching for paths
-                return matchesGlob(path, value);
+                // Glob pattern matching for paths
+                return matchesGlobPattern(path, value);
             case 'age':
                 // Time-based invalidation: age:3months, age:1week, age:30days
                 return matchesAge(entry, value);
@@ -92,113 +92,6 @@ export function matchesInvalidationTerm(entry, path, term) {
         return entry.tags.some((tag) => tag.includes(term)) || path.includes(term);
     }
 }
-/**
- * Simple glob pattern matching for paths.
- * Supports * and ** wildcards.
- *
- * @param path - Path to test
- * @param pattern - Glob pattern
- * @returns True if path matches pattern
- */
-function matchesGlob(path, pattern) {
-    try {
-        // Convert glob pattern to regex by processing character by character
-        // This avoids the magic string replacement issue
-        const regex = globToRegex(pattern);
-        return regex.test(path);
-    }
-    catch {
-        console.warn(`Invalid glob pattern: ${pattern}`);
-        return false;
-    }
-}
-/**
- * Converts a glob pattern to a regular expression.
- * Processes the pattern character by character to avoid placeholder conflicts.
- *
- * @param pattern - Glob pattern to convert
- * @returns Regular expression that matches the glob pattern
- */
-function globToRegex(pattern) {
-    let regexStr = '^';
-    let i = 0;
-    while (i < pattern.length) {
-        const char = pattern[i];
-        switch (char) {
-            case '*':
-                if (i + 1 < pattern.length && pattern[i + 1] === '*') {
-                    // Handle ** (matches any path including subdirectories)
-                    if (i + 2 < pattern.length && pattern[i + 2] === '/') {
-                        // **/ pattern - matches zero or more directories
-                        regexStr += '(?:.*/)?';
-                        i += 3;
-                    }
-                    else if (i + 2 === pattern.length) {
-                        // ** at end - matches everything
-                        regexStr += '.*';
-                        i += 2;
-                    }
-                    else {
-                        // ** not followed by / or end - treat as single *
-                        regexStr += '[^/]*';
-                        i += 1;
-                    }
-                }
-                else {
-                    // Single * matches any characters except path separator
-                    regexStr += '[^/]*';
-                    i += 1;
-                }
-                break;
-            case '?':
-                // ? matches any single character except path separator
-                regexStr += '[^/]';
-                i += 1;
-                break;
-            case '[': {
-                // Handle character classes - find the closing bracket
-                let closeIndex = i + 1;
-                while (closeIndex < pattern.length && pattern[closeIndex] !== ']') {
-                    closeIndex++;
-                }
-                if (closeIndex >= pattern.length) {
-                    // No closing bracket found - this creates an invalid regex
-                    // Just add the character and let the regex constructor throw an error
-                    regexStr += char;
-                    i += 1;
-                }
-                else {
-                    // Valid character class - copy it as-is
-                    regexStr += pattern.slice(i, closeIndex + 1);
-                    i = closeIndex + 1;
-                }
-                break;
-            }
-            case '.':
-            case '+':
-            case '^':
-            case '$':
-            case '(':
-            case ')':
-            case ']':
-            case '{':
-            case '}':
-            case '|':
-            case '\\':
-                // Escape regex special characters
-                regexStr += '\\' + char;
-                i += 1;
-                break;
-            default:
-                // Regular character
-                regexStr += char;
-                i += 1;
-                break;
-        }
-    }
-    regexStr += '$';
-    return new RegExp(regexStr);
-}
 /**
  * Checks if a cache entry matches an age-based invalidation term.
  * Supports various time units: days, weeks, months, years.

package/dist/core/utils/glob-patterns.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Glob pattern matching utilities for Stati
+ * Provides shared glob-to-regex conversion functionality
+ * @module core/utils/glob-patterns
+ */
+/**
+ * Converts a glob pattern to a regular expression.
+ * Combines features from both pattern-matching and invalidate implementations.
+ *
+ * Supports:
+ * - `**` - matches zero or more path segments
+ * - `*` - matches any characters except path separator
+ * - `?` - matches any single character except path separator
+ * - `[...]` - character classes
+ *
+ * @param pattern - Glob pattern to convert (backslashes are normalized to forward slashes)
+ * @returns Regular expression that matches the glob pattern
+ *
+ * @example
+ * ```typescript
+ * const regex = globToRegex('site/**\/*.md');
+ * regex.test('site/blog/post.md'); // true
+ * regex.test('site/blog/2024/post.md'); // true
+ * ```
+ */
+export declare function globToRegex(pattern: string): RegExp;
+/**
+ * Tests if a path matches a glob pattern
+ * @param path - Path to test
+ * @param pattern - Glob pattern
+ * @returns True if path matches pattern
+ *
+ * @example
+ * ```typescript
+ * matchesGlob('/blog/post', '/blog/**'); // true
+ * matchesGlob('/blog/post', '/news/**'); // false
+ * ```
+ */
+export declare function matchesGlob(path: string, pattern: string): boolean;
+//# sourceMappingURL=glob-patterns.d.ts.map

package/dist/core/utils/glob-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-patterns.d.ts","sourceRoot":"","sources":["../../../src/core/utils/glob-patterns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoFnD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAQlE"}

package/dist/core/utils/glob-patterns.js

@@ -0,0 +1,127 @@
+/**
+ * Glob pattern matching utilities for Stati
+ * Provides shared glob-to-regex conversion functionality
+ * @module core/utils/glob-patterns
+ */
+/**
+ * Converts a glob pattern to a regular expression.
+ * Combines features from both pattern-matching and invalidate implementations.
+ *
+ * Supports:
+ * - `**` - matches zero or more path segments
+ * - `*` - matches any characters except path separator
+ * - `?` - matches any single character except path separator
+ * - `[...]` - character classes
+ *
+ * @param pattern - Glob pattern to convert (backslashes are normalized to forward slashes)
+ * @returns Regular expression that matches the glob pattern
+ *
+ * @example
+ * ```typescript
+ * const regex = globToRegex('site/**\/*.md');
+ * regex.test('site/blog/post.md'); // true
+ * regex.test('site/blog/2024/post.md'); // true
+ * ```
+ */
+export function globToRegex(pattern) {
+    // Normalize pattern to use forward slashes for cross-platform compatibility
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+    let regexStr = '^';
+    let i = 0;
+    while (i < normalizedPattern.length) {
+        const char = normalizedPattern[i];
+        switch (char) {
+            case '*':
+                if (i + 1 < normalizedPattern.length && normalizedPattern[i + 1] === '*') {
+                    // Handle ** (matches zero or more path segments)
+                    if (i + 2 < normalizedPattern.length && normalizedPattern[i + 2] === '/') {
+                        // **/ pattern - matches zero or more directories
+                        regexStr += '(?:.*/)?';
+                        i += 3;
+                    }
+                    else if (i + 2 === normalizedPattern.length) {
+                        // ** at end - matches everything
+                        regexStr += '.*';
+                        i += 2;
+                    }
+                    else {
+                        // ** in middle not followed by / - match everything remaining
+                        regexStr += '.*';
+                        i += 2;
+                    }
+                }
+                else {
+                    // Single * matches any characters except path separator
+                    regexStr += '[^/]*';
+                    i += 1;
+                }
+                break;
+            case '?':
+                // ? matches any single character except path separator
+                regexStr += '[^/]';
+                i += 1;
+                break;
+            case '[': {
+                // Handle character classes - find the closing bracket
+                let closeIndex = i + 1;
+                while (closeIndex < normalizedPattern.length && normalizedPattern[closeIndex] !== ']') {
+                    closeIndex++;
+                }
+                if (closeIndex >= normalizedPattern.length) {
+                    // No closing bracket found - invalid pattern
+                    throw new Error(`Unclosed character class at position ${i}`);
+                }
+                else {
+                    // Valid character class - copy it as-is
+                    regexStr += normalizedPattern.slice(i, closeIndex + 1);
+                    i = closeIndex + 1;
+                }
+                break;
+            }
+            case '.':
+            case '+':
+            case '^':
+            case '$':
+            case '(':
+            case ')':
+            case ']':
+            case '{':
+            case '}':
+            case '|':
+            case '\\':
+                // Escape regex special characters
+                regexStr += '\\' + char;
+                i += 1;
+                break;
+            default:
+                // Regular character
+                regexStr += char;
+                i += 1;
+                break;
+        }
+    }
+    regexStr += '$';
+    return new RegExp(regexStr);
+}
+/**
+ * Tests if a path matches a glob pattern
+ * @param path - Path to test
+ * @param pattern - Glob pattern
+ * @returns True if path matches pattern
+ *
+ * @example
+ * ```typescript
+ * matchesGlob('/blog/post', '/blog/**'); // true
+ * matchesGlob('/blog/post', '/news/**'); // false
+ * ```
+ */
+export function matchesGlob(path, pattern) {
+    try {
+        const regex = globToRegex(pattern);
+        return regex.test(path);
+    }
+    catch {
+        console.warn(`Invalid glob pattern: ${pattern}`);
+        return false;
+    }
+}

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

@@ -17,4 +17,5 @@ export type { PrettyUrlResult } from './server.js';
 export { createErrorOverlay, parseErrorDetails } from './error-overlay.js';
 export type { ErrorDetails } from './error-overlay.js';
 export { getStatiVersion } from './version.js';
+export { globToRegex, matchesGlob } from './glob-patterns.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,QAAQ,EACR,SAAS,EACT,UAAU,EACV,SAAS,EACT,MAAM,EACN,QAAQ,EACR,OAAO,EACP,IAAI,GACL,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,2BAA2B,EAC3B,cAAc,EACd,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAGxE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AACrF,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/utils/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,QAAQ,EACR,SAAS,EACT,UAAU,EACV,SAAS,EACT,MAAM,EACN,QAAQ,EACR,OAAO,EACP,IAAI,GACL,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,2BAA2B,EAC3B,cAAc,EACd,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAGxE,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AACrF,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAGlE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC3E,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/core/utils/index.js

@@ -26,3 +26,5 @@ export { resolvePrettyUrl } from './server.js';
 export { createErrorOverlay, parseErrorDetails } from './error-overlay.js';
 // Version utilities
 export { getStatiVersion } from './version.js';
+// Glob pattern utilities
+export { globToRegex, matchesGlob } from './glob-patterns.js';

package/dist/index.d.ts

@@ -22,10 +22,13 @@
 export type { StatiConfig, PageModel, FrontMatter, BuildContext, PageContext, BuildHooks, NavNode, ISGConfig, AgingRule, BuildStats, } from './types/index.js';
 export type { SEOMetadata, SEOConfig, SEOContext, SEOValidationResult, SEOTagType, RobotsConfig, OpenGraphConfig, OpenGraphImage, OpenGraphArticle, TwitterCardConfig, AuthorConfig, } from './types/index.js';
 export type { SitemapConfig, SitemapEntry, SitemapGenerationResult, ChangeFrequency, } from './types/index.js';
+export type { RSSConfig, RSSFeedConfig, RSSGenerationResult } from './types/index.js';
 export type { BuildOptions, DevServerOptions, PreviewServerOptions, InvalidationResult, } from './core/index.js';
 export { build, createDevServer, createPreviewServer, invalidate } from './core/index.js';
 export type { AutoInjectOptions } from './seo/index.js';
 export { generateSEOMetadata, generateSEO, generateOpenGraphTags, generateTwitterCardTags, generateSitemap, generateSitemapEntry, generateSitemapXml, generateSitemapIndexXml, generateRobotsTxt, generateRobotsTxtFromConfig, escapeHtml, generateRobotsContent, validateSEOMetadata, detectExistingSEOTags, normalizeUrlPath, resolveAbsoluteUrl, isValidUrl, autoInjectSEO, shouldAutoInject, } from './seo/index.js';
+export type { RSSValidationResult } from './rss/index.js';
+export { generateRSSFeed, generateRSSFeeds, validateRSSConfig, validateRSSFeedConfig, } from './rss/index.js';
 export { loadConfig } from './config/loader.js';
 export { setEnv, getEnv } from './env.js';
 import type { StatiConfig } from './types/index.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,UAAU,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,aAAa,EACb,YAAY,EACZ,uBAAuB,EACvB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG1F,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAG1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,YAAY,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,EACX,UAAU,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,UAAU,GACX,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACV,WAAW,EACX,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,UAAU,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,GACb,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,aAAa,EACb,YAAY,EACZ,uBAAuB,EACvB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtF,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG1F,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,iBAAiB,EACjB,2BAA2B,EAC3B,UAAU,EACV,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAG1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAE7D"}

package/dist/index.js

@@ -21,6 +21,7 @@
  */
 export { build, createDevServer, createPreviewServer, invalidate } from './core/index.js';
 export { generateSEOMetadata, generateSEO, generateOpenGraphTags, generateTwitterCardTags, generateSitemap, generateSitemapEntry, generateSitemapXml, generateSitemapIndexXml, generateRobotsTxt, generateRobotsTxtFromConfig, escapeHtml, generateRobotsContent, validateSEOMetadata, detectExistingSEOTags, normalizeUrlPath, resolveAbsoluteUrl, isValidUrl, autoInjectSEO, shouldAutoInject, } from './seo/index.js';
+export { generateRSSFeed, generateRSSFeeds, validateRSSConfig, validateRSSFeedConfig, } from './rss/index.js';
 // Re-export config and env utilities
 export { loadConfig } from './config/loader.js';
 export { setEnv, getEnv } from './env.js';

package/dist/rss/generator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * RSS feed generation utilities for Stati
+ * @module rss/generator
+ */
+import type { PageModel } from '../types/content.js';
+import type { StatiConfig } from '../types/config.js';
+import type { RSSFeedConfig, RSSGenerationResult } from '../types/rss.js';
+import type { Logger } from '../types/logging.js';
+/**
+ * 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 declare function generateRSSFeed(pages: PageModel[], config: StatiConfig, feedConfig: RSSFeedConfig, logger?: Logger): RSSGenerationResult;
+/**
+ * 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 declare function generateRSSFeeds(pages: PageModel[], config: StatiConfig, logger?: Logger): RSSGenerationResult[];
+//# sourceMappingURL=generator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/rss/generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AA2KlD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,EAAE,EAClB,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,aAAa,EACzB,MAAM,CAAC,EAAE,MAAM,GACd,mBAAmB,CA4LrB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,EAAE,EAClB,MAAM,EAAE,WAAW,EACnB,MAAM,CAAC,EAAE,MAAM,GACd,mBAAmB,EAAE,CAcvB"}