npm - @stati/core - Versions diffs - 1.6.3 → 1.7.0 - Mend

@stati/core 1.6.3 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (82) hide show

package/README.md +2 -2
package/dist/core/build.d.ts.map +1 -1
package/dist/core/build.js +45 -8
package/dist/core/content.d.ts.map +1 -1
package/dist/core/content.js +1 -2
package/dist/core/dev.d.ts.map +1 -1
package/dist/core/dev.js +2 -5
package/dist/core/index.d.ts +13 -0
package/dist/core/index.d.ts.map +1 -0
package/dist/core/index.js +12 -0
package/dist/core/invalidate.d.ts.map +1 -1
package/dist/core/invalidate.js +13 -7
package/dist/core/isg/build-lock.js +1 -1
package/dist/core/isg/deps.d.ts.map +1 -1
package/dist/core/isg/deps.js +1 -3
package/dist/core/isg/hash.js +1 -1
package/dist/core/isg/index.d.ts +16 -0
package/dist/core/isg/index.d.ts.map +1 -0
package/dist/core/isg/index.js +22 -0
package/dist/core/isg/manifest.js +1 -1
package/dist/core/preview.d.ts.map +1 -1
package/dist/core/preview.js +1 -2
package/dist/core/templates.d.ts.map +1 -1
package/dist/core/templates.js +4 -7
package/dist/core/utils/index.d.ts +16 -0
package/dist/core/utils/index.d.ts.map +1 -0
package/dist/core/utils/index.js +22 -0
package/dist/core/utils/partial-validation.d.ts.map +1 -1
package/dist/core/utils/partial-validation.js +2 -1
package/dist/index.d.ts +6 -8
package/dist/index.d.ts.map +1 -1
package/dist/index.js +3 -4
package/dist/seo/auto-inject.d.ts +48 -0
package/dist/seo/auto-inject.d.ts.map +1 -0
package/dist/seo/auto-inject.js +108 -0
package/dist/seo/generator.d.ts +77 -0
package/dist/seo/generator.d.ts.map +1 -0
package/dist/seo/generator.js +320 -0
package/dist/seo/index.d.ts +12 -0
package/dist/seo/index.d.ts.map +1 -0
package/dist/seo/index.js +15 -0
package/dist/seo/robots.d.ts +84 -0
package/dist/seo/robots.d.ts.map +1 -0
package/dist/seo/robots.js +165 -0
package/dist/seo/sitemap.d.ts +37 -0
package/dist/seo/sitemap.d.ts.map +1 -0
package/dist/seo/sitemap.js +320 -0
package/dist/seo/utils/escape-and-validation.d.ts +99 -0
package/dist/seo/utils/escape-and-validation.d.ts.map +1 -0
package/dist/seo/utils/escape-and-validation.js +319 -0
package/dist/seo/utils/index.d.ts +7 -0
package/dist/seo/utils/index.d.ts.map +1 -0
package/dist/seo/utils/index.js +8 -0
package/dist/seo/utils/url.d.ts +46 -0
package/dist/seo/utils/url.d.ts.map +1 -0
package/dist/seo/utils/url.js +66 -0
package/dist/seo/utils.d.ts +94 -0
package/dist/seo/utils.d.ts.map +1 -0
package/dist/seo/utils.js +304 -0
package/dist/types/config.d.ts +58 -0
package/dist/types/config.d.ts.map +1 -1
package/dist/types/content.d.ts +181 -0
package/dist/types/content.d.ts.map +1 -1
package/dist/types/index.d.ts +5 -2
package/dist/types/index.d.ts.map +1 -1
package/dist/types/index.js +1 -1
package/dist/types/seo.d.ts +69 -0
package/dist/types/seo.d.ts.map +1 -0
package/dist/types/seo.js +36 -0
package/dist/types/sitemap.d.ts +94 -0
package/dist/types/sitemap.d.ts.map +1 -0
package/dist/types/sitemap.js +4 -0
package/package.json +1 -1
package/dist/core/utils/partials.d.ts +0 -24
package/dist/core/utils/partials.d.ts.map +0 -1
package/dist/core/utils/partials.js +0 -85
package/dist/tests/utils/test-mocks.d.ts +0 -69
package/dist/tests/utils/test-mocks.d.ts.map +0 -1
package/dist/tests/utils/test-mocks.js +0 -125
package/dist/types.d.ts +0 -543
package/dist/types.d.ts.map +0 -1
package/dist/types.js +0 -1

package/dist/seo/auto-inject.js ADDED Viewed

@@ -0,0 +1,108 @@
+/**
+ * Automatic SEO tag injection utilities
+ * @module seo/auto-inject
+ */
+import { detectExistingSEOTags } from './utils/index.js';
+import { generateSEOMetadata } from './generator.js';
+/**
+ * Helper function to conditionally log debug messages for SEO auto-injection.
+ * Checks both the explicit debug flag and the config-level debug setting.
+ *
+ * @param message - Debug message to log
+ * @param options - Object containing debug flag, config, and logger
+ */
+function logDebug(message, options) {
+    if (options.debug || options.config.seo?.debug) {
+        const logMessage = `[SEO Auto-Inject] ${message}`;
+        options.logger.warning(logMessage);
+    }
+}
+/**
+ * Finds the position to inject SEO tags (before </head>)
+ * @param html - HTML content
+ * @returns Position index or -1 if not found
+ */
+function findHeadClosePosition(html) {
+    // Case-insensitive search for </head>
+    const match = html.match(/<\/head>/i);
+    return match ? (match.index ?? -1) : -1;
+}
+/**
+ * Automatically injects SEO metadata into HTML if not already present
+ * @param html - Rendered HTML content
+ * @param options - Auto-injection options
+ * @returns HTML with injected SEO tags
+ *
+ * @example
+ * ```typescript
+ * const html = '<html><head><title>Page</title></head><body>Content</body></html>';
+ * const enhanced = autoInjectSEO(html, {
+ *   page: pageModel,
+ *   config: statiConfig,
+ *   siteUrl: 'https://example.com'
+ * });
+ * // Returns HTML with additional SEO meta tags injected
+ * ```
+ */
+export function autoInjectSEO(html, options) {
+    const { page, config, siteUrl, debug, logger } = options;
+    // Check if auto-injection is enabled (default: true)
+    const autoInjectEnabled = config.seo?.autoInject !== false;
+    if (!autoInjectEnabled) {
+        logDebug(`Skipped for ${page.url} (disabled in config)`, { debug, config, logger });
+        return html;
+    }
+    // Detect existing SEO tags in the HTML
+    const existingTags = detectExistingSEOTags(html);
+    logDebug(`Existing tags in ${page.url}: ${Array.from(existingTags).join(', ')}`, {
+        debug,
+        config,
+        logger,
+    });
+    // Build context with optional exclude parameter and logger
+    const context = {
+        page,
+        config,
+        siteUrl,
+        logger,
+    };
+    // Only add exclude if we have existing tags
+    if (existingTags.size > 0) {
+        context.exclude = existingTags;
+    }
+    // Generate SEO metadata excluding existing tags
+    const seoMetadata = generateSEOMetadata(context);
+    // If no SEO metadata was generated (all tags exist), return original HTML
+    if (!seoMetadata || seoMetadata.trim().length === 0) {
+        logDebug(`No tags to inject for ${page.url} (all exist)`, { debug, config, logger });
+        return html;
+    }
+    // Find position to inject (before </head>)
+    const headClosePos = findHeadClosePosition(html);
+    if (headClosePos === -1) {
+        logDebug(`No </head> tag found in ${page.url}, skipping injection`, { debug, config, logger });
+        return html;
+    }
+    // Inject SEO metadata before </head>
+    const before = html.substring(0, headClosePos);
+    const after = html.substring(headClosePos);
+    // Add proper indentation (2 spaces) and newline
+    const injected = `${before}  ${seoMetadata}\n${after}`;
+    logDebug(`Injected ${existingTags.size === 0 ? 'all' : 'missing'} SEO tags into ${page.url}`, {
+        debug,
+        config,
+        logger,
+    });
+    return injected;
+}
+/**
+ * Checks if auto-injection is enabled for a page
+ * @param config - Site configuration
+ * @param _page - Page model (reserved for future page-level overrides)
+ * @returns true if auto-injection should run
+ */
+export function shouldAutoInject(config, _page) {
+    // Check global config
+    const globalEnabled = config.seo?.autoInject !== false;
+    return globalEnabled;
+}

package/dist/seo/generator.d.ts ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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"}