@xexr/blog-platform 1.0.12 → 1.0.14

package/dist/lib/sitemap.ts

@@ -30,12 +30,14 @@ import type {
   PublishedSite,
   PublishedAuthor,
 } from "../types/contracts";
+import { getAuthorsFromArticles } from "./authors";
 import {
   generateCanonicalUrl,
   normalizeDomain,
   type CanonicalUrlOptions,
 } from "./seo";
-import { buildAuthorPath } from "./urls";
+import { getAllTopics } from "./topics";
+import { buildAuthorPath, buildBlogPath } from "./urls";
 
 /**
  * Configuration options for sitemap generation.
@@ -47,6 +49,9 @@ export interface SitemapOptions {
   /** Whether to include author pages in sitemap */
   includeAuthorPages?: boolean;
 
+  /** Whether to include topic pages in sitemap */
+  includeTopicPages?: boolean;
+
   /** Whether to include pagination pages in sitemap */
   includePaginationPages?: boolean;
 
@@ -64,6 +69,8 @@ export interface SitemapOptions {
     articles?: SitemapChangeFreq;
     /** Change frequency for author pages */
     authorPages?: SitemapChangeFreq;
+    /** Change frequency for topic index and archive pages */
+    topicPages?: SitemapChangeFreq;
     /** Change frequency for pagination pages */
     paginationPages?: SitemapChangeFreq;
   };
@@ -76,6 +83,8 @@ export interface SitemapOptions {
     articles?: number;
     /** Priority for author pages (0.0-1.0) */
     authorPages?: number;
+    /** Priority for topic index and archive pages (0.0-1.0) */
+    topicPages?: number;
     /** Priority for pagination pages (0.0-1.0) */
     paginationPages?: number;
   };
@@ -194,6 +203,7 @@ export async function generateBlogSitemapEntries(
 ): Promise<NextjsSitemapEntry[]> {
   const {
     includeAuthorPages = true,
+    includeTopicPages = true,
     includePaginationPages = true,
     articlesPerPage = 10,
     maxEntries = 50000,
@@ -208,6 +218,9 @@ export async function generateBlogSitemapEntries(
   );
 
   const pathPrefix = options.canonical?.pathPrefix ?? "/blog";
+  const sitemapAuthors =
+    authors.length > 0 ? authors : getAuthorsFromArticles(articles);
+  const sitemapTopics = getAllTopics([...articles]);
 
   // Add blog home page
   entries.push({
@@ -230,9 +243,44 @@ export async function generateBlogSitemapEntries(
     });
   });
 
+  if (includeTopicPages && sitemapTopics.length > 0) {
+    if (entries.length < maxEntries) {
+      entries.push({
+        url: `${baseUrl}${buildBlogPath(pathPrefix, "topics")}`,
+        lastModified: getLatestModificationDate(articles),
+        changeFrequency: changeFrequency.topicPages ?? "weekly",
+        priority: priority.topicPages ?? 0.6,
+      });
+    }
+
+    sitemapTopics.forEach((topic) => {
+      if (entries.length >= maxEntries) return;
+
+      const topicArticles = articles.filter((article) =>
+        (article.topics ?? []).some((candidate) => candidate.slug === topic.slug),
+      );
+
+      entries.push({
+        url: `${baseUrl}${buildBlogPath(pathPrefix, `topics/${topic.slug}`)}`,
+        lastModified: getLatestModificationDate(topicArticles),
+        changeFrequency: changeFrequency.topicPages ?? "weekly",
+        priority: priority.topicPages ?? 0.6,
+      });
+    });
+  }
+
   // Add author pages if enabled
-  if (includeAuthorPages) {
-    authors.forEach((author) => {
+  if (includeAuthorPages && sitemapAuthors.length > 0) {
+    if (entries.length < maxEntries) {
+      entries.push({
+        url: `${baseUrl}${buildBlogPath(pathPrefix, "authors")}`,
+        lastModified: getLatestModificationDate(articles),
+        changeFrequency: changeFrequency.authorPages ?? "weekly",
+        priority: priority.authorPages ?? 0.6,
+      });
+    }
+
+    sitemapAuthors.forEach((author) => {
       if (entries.length >= maxEntries) return;
 
       const authorUrl = `${baseUrl}${buildAuthorPath(pathPrefix, author.slug)}`;
@@ -289,6 +337,7 @@ export function generateSitemap(
 ): SitemapData {
   const {
     includeAuthorPages = true,
+    includeTopicPages = true,
     includePaginationPages = true,
     articlesPerPage = 10,
     maxEntries = 50000,
@@ -304,12 +353,18 @@ export function generateSitemap(
 
   const pathPrefix = options.canonical?.pathPrefix ?? "/blog";
   const generatedAt = new Date().toISOString();
+  const sitemapAuthors =
+    authors.length > 0 ? authors : getAuthorsFromArticles(articles);
+  const sitemapTopics = getAllTopics([...articles]);
 
   // Calculate total potential entries to determine if truncation will occur
   let potentialEntries = 1; // Home page
   potentialEntries += articles.length; // Article pages
+  if (includeTopicPages && sitemapTopics.length > 0) {
+    potentialEntries += sitemapTopics.length + 1; // Topic index + topic pages
+  }
   if (includeAuthorPages) {
-    potentialEntries += authors.length; // Author pages
+    potentialEntries += sitemapAuthors.length > 0 ? sitemapAuthors.length + 1 : 0; // Authors index + author pages
   }
   if (includePaginationPages && articles.length > articlesPerPage) {
     const totalPages = Math.ceil(articles.length / articlesPerPage);
@@ -339,9 +394,44 @@ export function generateSitemap(
     });
   });
 
+  if (includeTopicPages && sitemapTopics.length > 0) {
+    if (entries.length < maxEntries) {
+      entries.push({
+        loc: `${baseUrl}${buildBlogPath(pathPrefix, "topics")}`,
+        lastmod: getLatestModificationDate(articles),
+        changefreq: changeFrequency.topicPages ?? "weekly",
+        priority: priority.topicPages ?? 0.6,
+      });
+    }
+
+    sitemapTopics.forEach((topic) => {
+      if (entries.length >= maxEntries) return;
+
+      const topicArticles = articles.filter((article) =>
+        (article.topics ?? []).some((candidate) => candidate.slug === topic.slug),
+      );
+
+      entries.push({
+        loc: `${baseUrl}${buildBlogPath(pathPrefix, `topics/${topic.slug}`)}`,
+        lastmod: getLatestModificationDate(topicArticles),
+        changefreq: changeFrequency.topicPages ?? "weekly",
+        priority: priority.topicPages ?? 0.6,
+      });
+    });
+  }
+
   // Add author pages if enabled
-  if (includeAuthorPages) {
-    authors.forEach((author) => {
+  if (includeAuthorPages && sitemapAuthors.length > 0) {
+    if (entries.length < maxEntries) {
+      entries.push({
+        loc: `${baseUrl}${buildBlogPath(pathPrefix, "authors")}`,
+        lastmod: getLatestModificationDate(articles),
+        changefreq: changeFrequency.authorPages ?? "weekly",
+        priority: priority.authorPages ?? 0.6,
+      });
+    }
+
+    sitemapAuthors.forEach((author) => {
       if (entries.length >= maxEntries) return;
 
       const authorUrl = `${baseUrl}${buildAuthorPath(pathPrefix, author.slug)}`;
@@ -654,6 +744,12 @@ export function createBlogSitemapRoute(
  * Used to fetch blog data for sitemap generation.
  */
 export interface BlogSitemapConfig {
+  /** Static host app routes to include before Bloggy routes */
+  staticRoutes?: readonly NextjsSitemapEntry[];
+
+  /** Function to fetch static host app routes */
+  getStaticRoutes?: () => Promise<readonly NextjsSitemapEntry[]>;
+
   /** Function to fetch site data */
   getSite: () => Promise<PublishedSite>;
 
@@ -693,11 +789,23 @@ export interface BlogSitemapConfig {
  */
 export function createDynamicBlogSitemap(config: BlogSitemapConfig) {
   return async function sitemap(): Promise<NextjsSitemapEntry[]> {
+    const staticRoutes = [
+      ...(config.staticRoutes ?? []),
+      ...(config.getStaticRoutes ? await config.getStaticRoutes() : []),
+    ];
     const site = await config.getSite();
     const articles = await config.getArticles();
     const authors = config.getAuthors ? await config.getAuthors() : [];
 
-    return generateBlogSitemapEntries(site, articles, authors, config.options);
+    return [
+      ...staticRoutes,
+      ...(await generateBlogSitemapEntries(
+        site,
+        articles,
+        authors,
+        config.options,
+      )),
+    ];
   };
 }
 

package/dist/sitemap-BPTdXb9C.d.ts

@@ -0,0 +1,422 @@
+import { PublishedArticle, PublishedSite, PublishedAuthor } from './types/index.js';
+
+/**
+ * SEO utilities for canonical URL generation and validation.
+ *
+ * These utilities ensure proper canonical URL structure for SEO optimization,
+ * preventing duplicate content issues and improving search engine indexing.
+ */
+
+/**
+ * Configuration options for canonical URL generation.
+ */
+interface CanonicalUrlOptions {
+    /** Whether to force HTTPS protocol (default: true) */
+    forceHttps?: boolean;
+    /** Whether to remove trailing slashes (default: true) */
+    removeTrailingSlash?: boolean;
+    /** Custom domain override (uses site.domain if not provided) */
+    domain?: string;
+    /** Custom path prefix (default: '/blog') */
+    pathPrefix?: string;
+}
+/**
+ * Normalizes a domain by ensuring proper protocol and removing trailing slashes.
+ *
+ * @param domain - The domain to normalize
+ * @param forceHttps - Whether to force HTTPS protocol
+ * @returns The normalized domain
+ *
+ * @example
+ * ```typescript
+ * normalizeDomain('example.com') // 'https://example.com'
+ * normalizeDomain('http://example.com/') // 'https://example.com'
+ * normalizeDomain('https://example.com', false) // 'https://example.com'
+ * ```
+ */
+declare function normalizeDomain(domain: string, forceHttps?: boolean): string;
+/**
+ * Validates and normalizes a slug for URL usage.
+ *
+ * @param slug - The slug to validate and normalize
+ * @returns The normalized slug
+ * @throws Error if slug is invalid
+ *
+ * @example
+ * ```typescript
+ * normalizeSlug('hello-world') // 'hello-world'
+ * normalizeSlug('Hello World!') // throws Error
+ * normalizeSlug('hello--world') // 'hello-world'
+ * ```
+ */
+declare function normalizeSlug(slug: string): string;
+/**
+ * Generates a canonical URL for an article.
+ *
+ * @param article - The published article
+ * @param options - Configuration options for URL generation
+ * @returns The canonical URL
+ * @throws Error if article or site data is invalid
+ *
+ * @example
+ * ```typescript
+ * const article = {
+ *   slug: 'hello-world',
+ *   site: { domain: 'example.com' },
+ *   // ... other fields
+ * };
+ *
+ * generateCanonicalUrl(article)
+ * // 'https://example.com/blog/hello-world'
+ *
+ * generateCanonicalUrl(article, { pathPrefix: '/posts' })
+ * // 'https://example.com/posts/hello-world'
+ * ```
+ */
+declare function generateCanonicalUrl(article: PublishedArticle, options?: CanonicalUrlOptions): string;
+/**
+ * Generates a canonical URL for an article from site and slug data.
+ * Useful when you don't have a full PublishedArticle object.
+ *
+ * @param site - The published site
+ * @param slug - The article slug
+ * @param options - Configuration options for URL generation
+ * @returns The canonical URL
+ *
+ * @example
+ * ```typescript
+ * const site = { domain: 'example.com', ... };
+ * generateCanonicalUrlFromSlug(site, 'hello-world')
+ * // 'https://example.com/blog/hello-world'
+ * ```
+ */
+declare function generateCanonicalUrlFromSlug(site: PublishedSite, slug: string, options?: CanonicalUrlOptions): string;
+/**
+ * Validates if a URL is a valid canonical URL format.
+ *
+ * @param url - The URL to validate
+ * @returns True if the URL is valid for canonical use
+ *
+ * @example
+ * ```typescript
+ * isValidCanonicalUrl('https://example.com/blog/hello-world') // true
+ * isValidCanonicalUrl('http://example.com/blog/hello-world') // true
+ * isValidCanonicalUrl('example.com/blog/hello-world') // false (missing protocol)
+ * isValidCanonicalUrl('https://example.com/blog/hello world') // false (spaces)
+ * ```
+ */
+declare function isValidCanonicalUrl(url: string): boolean;
+/**
+ * Extracts the base URL (protocol + hostname + port) from a canonical URL.
+ *
+ * @param canonicalUrl - The canonical URL
+ * @returns The base URL
+ *
+ * @example
+ * ```typescript
+ * getBaseUrl('https://example.com/blog/hello-world') // 'https://example.com'
+ * getBaseUrl('https://blog.example.com:8080/posts/test') // 'https://blog.example.com:8080'
+ * ```
+ */
+declare function getBaseUrl(canonicalUrl: string): string;
+/**
+ * Updates an article's canonical URL in its meta field.
+ *
+ * @param article - The article to update
+ * @param options - Configuration options for URL generation
+ * @returns A new article object with updated canonical URL
+ *
+ * @example
+ * ```typescript
+ * const updatedArticle = updateArticleCanonicalUrl(article);
+ * console.log(updatedArticle.meta.canonicalUrl); // Generated canonical URL
+ * ```
+ */
+declare function updateArticleCanonicalUrl(article: PublishedArticle, options?: CanonicalUrlOptions): PublishedArticle;
+
+/**
+ * Next.js-compatible sitemap generation utilities for blog platform integration.
+ *
+ * These utilities generate sitemap entries that follow Next.js MetadataRoute.Sitemap
+ * conventions, allowing seamless integration with existing Next.js applications.
+ *
+ * @example Integration with existing Next.js sitemap:
+ * ```typescript
+ * // app/sitemap.ts
+ * import { generateBlogSitemapEntries } from '@xexr/blog-platform';
+ * import type { MetadataRoute } from 'next';
+ *
+ * export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+ *   // Your existing routes
+ *   const staticRoutes = [
+ *     { url: 'https://yoursite.com', lastModified: new Date(), priority: 1 },
+ *     { url: 'https://yoursite.com/about', lastModified: new Date(), priority: 0.8 }
+ *   ];
+ *
+ *   // Blog platform entries
+ *   const blogEntries = await generateBlogSitemapEntries(blogConfig);
+ *
+ *   return [...staticRoutes, ...blogEntries];
+ * }
+ * ```
+ */
+
+/**
+ * Configuration options for sitemap generation.
+ */
+interface SitemapOptions {
+    /** Canonical URL configuration */
+    canonical?: CanonicalUrlOptions;
+    /** Whether to include author pages in sitemap */
+    includeAuthorPages?: boolean;
+    /** Whether to include topic pages in sitemap */
+    includeTopicPages?: boolean;
+    /** Whether to include pagination pages in sitemap */
+    includePaginationPages?: boolean;
+    /** Number of articles per page for pagination calculation */
+    articlesPerPage?: number;
+    /** Maximum number of sitemap entries (defaults to 50,000 per Google guidelines) */
+    maxEntries?: number;
+    /** Change frequency for different page types */
+    changeFrequency?: {
+        /** Change frequency for blog home page */
+        homePage?: SitemapChangeFreq;
+        /** Change frequency for article pages */
+        articles?: SitemapChangeFreq;
+        /** Change frequency for author pages */
+        authorPages?: SitemapChangeFreq;
+        /** Change frequency for topic index and archive pages */
+        topicPages?: SitemapChangeFreq;
+        /** Change frequency for pagination pages */
+        paginationPages?: SitemapChangeFreq;
+    };
+    /** Priority values for different page types */
+    priority?: {
+        /** Priority for blog home page (0.0-1.0) */
+        homePage?: number;
+        /** Priority for article pages (0.0-1.0) */
+        articles?: number;
+        /** Priority for author pages (0.0-1.0) */
+        authorPages?: number;
+        /** Priority for topic index and archive pages (0.0-1.0) */
+        topicPages?: number;
+        /** Priority for pagination pages (0.0-1.0) */
+        paginationPages?: number;
+    };
+}
+/**
+ * Valid sitemap change frequency values as per XML sitemap standard.
+ */
+type SitemapChangeFreq = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+/**
+ * Next.js MetadataRoute.Sitemap compatible entry.
+ * This matches the expected format for Next.js sitemap generation.
+ */
+interface NextjsSitemapEntry {
+    /** The URL of the page */
+    url: string;
+    /** Last modification date */
+    lastModified?: string | Date;
+    /** Change frequency hint for search engines */
+    changeFrequency?: SitemapChangeFreq;
+    /** Priority relative to other URLs on the site (0.0-1.0) */
+    priority?: number;
+    /** Alternate language versions (for i18n) */
+    alternates?: {
+        languages?: Record<string, string>;
+    };
+}
+/**
+ * Legacy XML sitemap entry format (for backward compatibility).
+ * @deprecated Use NextjsSitemapEntry for new implementations
+ */
+interface SitemapEntry {
+    /** The URL of the page */
+    loc: string;
+    /** Last modification date as ISO 8601 string */
+    lastmod?: string;
+    /** Change frequency hint for search engines */
+    changefreq?: SitemapChangeFreq;
+    /** Priority relative to other URLs on the site (0.0-1.0) */
+    priority?: number;
+}
+/**
+ * Complete sitemap data structure.
+ */
+interface SitemapData {
+    /** All URL entries in the sitemap */
+    entries: SitemapEntry[];
+    /** Total number of entries */
+    totalEntries: number;
+    /** Whether the sitemap was truncated due to size limits */
+    truncated: boolean;
+    /** Generation timestamp */
+    generatedAt: string;
+    /** Base URL used for canonical URL generation */
+    baseUrl: string;
+}
+/**
+ * Generates Next.js-compatible sitemap entries for blog platform integration.
+ *
+ * @param site - The published site information
+ * @param articles - Array of published articles
+ * @param authors - Array of published authors (optional)
+ * @param options - Sitemap generation options
+ * @returns Array of Next.js MetadataRoute.Sitemap compatible entries
+ *
+ * @example
+ * ```typescript
+ * // In your Next.js app/sitemap.ts file:
+ * import { generateBlogSitemapEntries } from '@xexr/blog-platform';
+ * import type { MetadataRoute } from 'next';
+ *
+ * export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+ *   const blogEntries = await generateBlogSitemapEntries(site, articles, authors, {
+ *     includeAuthorPages: true,
+ *     includePaginationPages: true,
+ *     changeFrequency: { articles: 'monthly' }
+ *   });
+ *
+ *   return [
+ *     // Your existing site routes
+ *     { url: 'https://yoursite.com', lastModified: new Date(), priority: 1 },
+ *     { url: 'https://yoursite.com/about', lastModified: new Date() },
+ *     // Blog entries
+ *     ...blogEntries
+ *   ];
+ * }
+ * ```
+ */
+declare function generateBlogSitemapEntries(site: PublishedSite, articles: readonly PublishedArticle[], authors?: readonly PublishedAuthor[], options?: SitemapOptions): Promise<NextjsSitemapEntry[]>;
+/**
+ * Legacy sitemap generation for backward compatibility.
+ * @deprecated Use generateBlogSitemapEntries for Next.js integration
+ *
+ * @param site - The published site information
+ * @param articles - Array of published articles
+ * @param authors - Array of published authors (optional)
+ * @param options - Sitemap generation options
+ * @returns Complete sitemap data
+ */
+declare function generateSitemap(site: PublishedSite, articles: readonly PublishedArticle[], authors?: readonly PublishedAuthor[], options?: SitemapOptions): SitemapData;
+/**
+ * Converts sitemap data to XML format.
+ *
+ * @param sitemapData - The sitemap data to convert
+ * @returns XML string in sitemap format
+ *
+ * @example
+ * ```typescript
+ * const sitemap = generateSitemap(site, articles);
+ * const xmlString = sitemapToXml(sitemap);
+ * // Use in API route response
+ * ```
+ */
+declare function sitemapToXml(sitemapData: SitemapData): string;
+/**
+ * Generates a sitemap index for large blogs that need multiple sitemaps.
+ *
+ * @param sitemaps - Array of sitemap information
+ * @param baseUrl - Base URL for the site
+ * @returns XML string for sitemap index
+ *
+ * @example
+ * ```typescript
+ * const sitemapIndex = generateSitemapIndex([
+ *   { url: 'https://example.com/sitemap-articles.xml', lastmod: '2023-01-01T00:00:00Z' },
+ *   { url: 'https://example.com/sitemap-authors.xml', lastmod: '2023-01-01T00:00:00Z' }
+ * ], 'https://example.com');
+ * ```
+ */
+declare function generateSitemapIndex(sitemaps: readonly {
+    url: string;
+    lastmod?: string;
+}[], _baseUrl: string): string;
+/**
+ * Validates sitemap data for compliance with search engine guidelines.
+ *
+ * @param sitemapData - The sitemap data to validate
+ * @returns Validation results with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const sitemap = generateSitemap(site, articles);
+ * const validation = validateSitemap(sitemap);
+ *
+ * if (validation.errors.length > 0) {
+ *   console.error('Sitemap errors:', validation.errors);
+ * }
+ * ```
+ */
+declare function validateSitemap(sitemapData: SitemapData): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Creates a separate sitemap specifically for blog content.
+ * Useful for large sites that need to split sitemaps by content type.
+ *
+ * @param site - The published site information
+ * @param articles - Array of published articles
+ * @param authors - Array of published authors (optional)
+ * @param options - Sitemap generation options
+ * @returns Next.js sitemap function
+ *
+ * @example
+ * ```typescript
+ * // app/blog-sitemap/route.ts - separate blog sitemap endpoint
+ * import { createBlogSitemapRoute } from '@xexr/blog-platform';
+ *
+ * export const GET = createBlogSitemapRoute(site, articles, authors, {
+ *   includeAuthorPages: true,
+ *   articlesPerPage: 20
+ * });
+ * ```
+ */
+declare function createBlogSitemapRoute(site: PublishedSite, articles: readonly PublishedArticle[], authors?: readonly PublishedAuthor[], options?: SitemapOptions): () => Promise<Response>;
+/**
+ * Configuration interface for blog data fetching.
+ * Used to fetch blog data for sitemap generation.
+ */
+interface BlogSitemapConfig {
+    /** Static host app routes to include before Bloggy routes */
+    staticRoutes?: readonly NextjsSitemapEntry[];
+    /** Function to fetch static host app routes */
+    getStaticRoutes?: () => Promise<readonly NextjsSitemapEntry[]>;
+    /** Function to fetch site data */
+    getSite: () => Promise<PublishedSite>;
+    /** Function to fetch published articles */
+    getArticles: () => Promise<readonly PublishedArticle[]>;
+    /** Function to fetch authors (optional) */
+    getAuthors?: () => Promise<readonly PublishedAuthor[]>;
+    /** Sitemap generation options */
+    options?: SitemapOptions;
+}
+/**
+ * Higher-order function that creates a Next.js sitemap function with data fetching.
+ * Ideal for dynamic blog content that needs to be fetched at sitemap generation time.
+ *
+ * @param config - Configuration for fetching blog data
+ * @returns Next.js sitemap function
+ *
+ * @example
+ * ```typescript
+ * // app/sitemap.ts
+ * import { createDynamicBlogSitemap } from '@xexr/blog-platform';
+ * import { getBlogData } from './lib/blog';
+ *
+ * export default createDynamicBlogSitemap({
+ *   getSite: () => getBlogData().site,
+ *   getArticles: () => getBlogData().articles,
+ *   getAuthors: () => getBlogData().authors,
+ *   options: {
+ *     includeAuthorPages: true,
+ *     changeFrequency: { articles: 'weekly' }
+ *   }
+ * });
+ * ```
+ */
+declare function createDynamicBlogSitemap(config: BlogSitemapConfig): () => Promise<NextjsSitemapEntry[]>;
+
+export { type BlogSitemapConfig as B, type CanonicalUrlOptions as C, type NextjsSitemapEntry as N, type SitemapChangeFreq as S, type SitemapData as a, type SitemapEntry as b, type SitemapOptions as c, createBlogSitemapRoute as d, createDynamicBlogSitemap as e, generateCanonicalUrl as f, generateBlogSitemapEntries as g, generateCanonicalUrlFromSlug as h, generateSitemap as i, generateSitemapIndex as j, getBaseUrl as k, isValidCanonicalUrl as l, normalizeSlug as m, normalizeDomain as n, sitemapToXml as s, updateArticleCanonicalUrl as u, validateSitemap as v };