sitero 0.2.0 → 0.3.0

package/dist/src/web/server/seo/metadata/build-metadata.js

@@ -1,129 +1,84 @@
-import 'mime-types';
-import 'sitero-domain';
-import { findTranslation } from '../../../../shared/translation/find-translation.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import { joinUrl } from '../../../../shared/utils/join-url.js';
 import { toIsoTime } from '../../../../shared/utils/to-iso-time.js';
-import 'zod';
 import { buildAlternateMap } from './utils/build-alternate-map.js';
 import { buildOgImages } from './utils/build-og-image.js';
 import { ensureOgType } from './utils/ensure-og-type.js';
 import { ensureTwitterCard } from './utils/ensure-twitter-card.js';
+import { resolveRobots } from './utils/resolve-robots.js';
 import { sanitizeStringArray } from './utils/sanitize-string-array.js';
 import { toOgLocale } from './utils/to-og-locale.js';
 
+const text = (value) => value?.trim() || void 0;
 function createBuildMetadata(ctx) {
-  const { siteConfig, storageUrl } = ctx.constants;
-  return function buildMetadata(urls, post, locale, isArticle = false) {
-    const { defaultLocale, webLocales: locales, site } = siteConfig;
+  const { siteConfig, webClientIntorConfig } = ctx.constants;
+  return function buildMetadata(urls, post, locale, isArticle = false, options = {}) {
+    const { site, sharing } = siteConfig;
+    const { defaultLocale, supportedLocales: locales } = webClientIntorConfig;
     const resolvedLocale = locale || defaultLocale;
-    const seoMetadata = findTranslation(post?.seoMetadatas, locale);
-    const authorT = findTranslation(post?.author?.translations, locale);
-    const coverImageT = findTranslation(post?.coverImage?.translations, locale);
-    const tags = sanitizeStringArray(
-      post?.tags.map((t) => findTranslation(t.translations, locale).title)
+    const seo = post?.seoMetadatas.find(
+      (item) => item.locale === resolvedLocale
     );
-    const articleCoverImageUrl = joinUrl(storageUrl, post?.coverImage?.key);
+    const title = text(seo?.title);
+    const description = text(seo?.description);
+    const canonical = text(seo?.canonical) || urls.canonical;
+    const ogTitle = text(seo?.ogTitle) || title;
+    const ogDescription = text(seo?.ogDescription) || description;
+    const ogImage = text(seo?.ogImage);
+    const images = ogImage ? buildOgImages({
+      url: ogImage,
+      secureUrl: ogImage.startsWith("https://") ? ogImage : void 0,
+      alt: text(seo?.ogImageAlt),
+      type: text(seo?.ogImageType),
+      width: seo?.ogImageWidth,
+      height: seo?.ogImageHeight
+    }) : buildOgImages({
+      url: sharing.defaultImage.url,
+      secureUrl: sharing.defaultImage.url.startsWith("https://") ? sharing.defaultImage.url : void 0,
+      alt: sharing.defaultImage.alt,
+      type: sharing.defaultImage.mimeType,
+      width: sharing.defaultImage.width,
+      height: sharing.defaultImage.height
+    });
+    const author = text(seo?.author);
+    const articleAuthor = text(seo?.ogArticleAuthor);
     return {
-      metadataBase: site.url,
-      // -----------------------------------------------------------------------
-      // Basic
-      // -----------------------------------------------------------------------
-      title: seoMetadata.title || site.name[resolvedLocale],
-      description: seoMetadata.description || site.description[resolvedLocale],
-      // identity
-      ...isArticle ? {
-        authors: [
-          {
-            name: seoMetadata.author || authorT.authorName || void 0,
-            url: authorT.url || void 0
-          }
-        ]
-      } : {},
-      // url
+      metadataBase: new URL(site.url),
+      title: title ?? null,
+      description: description ?? null,
+      authors: isArticle && author ? [{ name: author }] : null,
       alternates: {
-        canonical: seoMetadata.canonical || urls.canonical,
-        languages: seoMetadata.alternate?.length ? buildAlternateMap(seoMetadata.alternate) : urls.alternates
+        canonical,
+        languages: seo?.alternate?.length ? buildAlternateMap(seo.alternate) : urls.alternates
       },
-      // robots
-      robots: seoMetadata.robots || {
-        index: true,
-        follow: true,
-        "max-image-preview": "large"
-      },
-      // -----------------------------------------------------------------------
-      // Open Graph
-      // -----------------------------------------------------------------------
+      robots: resolveRobots(
+        seo?.robots,
+        !!ctx.constants.forceNoIndex || !!options.forceNoIndex
+      ),
       openGraph: {
-        title: seoMetadata.ogTitle || void 0,
-        description: seoMetadata.ogDescription || void 0,
-        // url
-        url: seoMetadata.ogUrl || seoMetadata.canonical || void 0,
-        // identity
-        type: ensureOgType(
-          isArticle ? "article" : "website",
-          seoMetadata.ogType
-        ),
-        siteName: seoMetadata.ogSiteName || site.name[resolvedLocale],
-        // image
-        images: isArticle ? buildOgImages({
-          url: seoMetadata.ogImage || articleCoverImageUrl,
-          secureUrl: seoMetadata.ogImage || articleCoverImageUrl,
-          alt: seoMetadata.ogImageAlt || coverImageT.alt,
-          type: seoMetadata.ogImageType,
-          width: seoMetadata.ogImageWidth,
-          height: seoMetadata.ogImageHeight
-        }) : (
-          // is `website`
-          seoMetadata.ogImage ? buildOgImages({
-            url: seoMetadata.ogImage,
-            secureUrl: seoMetadata.ogImage,
-            alt: seoMetadata.ogImageAlt,
-            type: seoMetadata.ogImageType,
-            width: seoMetadata.ogImageWidth,
-            height: seoMetadata.ogImageHeight
-          }) : (
-            // default
-            buildOgImages({
-              url: site.defaultImage.url,
-              secureUrl: site.defaultImage.url,
-              alt: site.defaultImage.alt,
-              type: site.defaultImage.mimeType,
-              width: site.defaultImage.width,
-              height: site.defaultImage.height
-            })
-          )
-        ),
-        // locale
-        locale: seoMetadata.ogLocale || toOgLocale(resolvedLocale),
+        title: ogTitle,
+        description: ogDescription,
+        url: text(seo?.ogUrl) || canonical,
+        type: ensureOgType(isArticle ? "article" : "website", seo?.ogType),
+        siteName: text(seo?.ogSiteName) || site.name[resolvedLocale],
+        images,
+        locale: text(seo?.ogLocale) || toOgLocale(resolvedLocale),
         alternateLocale: sanitizeStringArray(
-          seoMetadata.ogLocaleAlternate?.length ? seoMetadata.ogLocaleAlternate : locales.filter((l) => l !== resolvedLocale).map(toOgLocale)
+          seo?.ogLocaleAlternate?.length ? seo.ogLocaleAlternate : locales.filter((l) => l !== resolvedLocale).map(toOgLocale)
         ),
-        // article
         ...isArticle ? {
-          publishedTime: toIsoTime(seoMetadata.ogArticlePublishedTime),
-          modifiedTime: toIsoTime(seoMetadata.ogArticleModifiedTime),
-          authors: [
-            seoMetadata.ogArticleAuthor || authorT.authorName
-          ].filter(Boolean),
-          section: seoMetadata.ogArticleSection,
-          tags: sanitizeStringArray(seoMetadata.ogArticleTag) || tags
+          publishedTime: toIsoTime(seo?.ogArticlePublishedTime),
+          modifiedTime: toIsoTime(seo?.ogArticleModifiedTime),
+          authors: articleAuthor ? [articleAuthor] : void 0,
+          section: text(seo?.ogArticleSection),
+          tags: sanitizeStringArray(seo?.ogArticleTag)
         } : {}
       },
-      // -----------------------------------------------------------------------
-      // Twitter
-      // -----------------------------------------------------------------------
       twitter: {
-        card: ensureTwitterCard("summary_large_image", seoMetadata.twitterCard),
-        // identity
-        site: seoMetadata.twitterSite || void 0,
-        creator: seoMetadata.twitterCreator || void 0
+        card: ensureTwitterCard("summary_large_image", seo?.twitterCard),
+        title: ogTitle,
+        description: ogDescription,
+        images,
+        site: text(seo?.twitterSite),
+        creator: text(seo?.twitterCreator)
       }
     };
   };

package/dist/src/web/server/seo/metadata/resolve-urls.js

@@ -3,12 +3,9 @@ import { readIntorUrlState } from 'intor/next/server';
 import { buildAlternatePathnames } from './build-alternate-pathnames.js';
 
 function createResolveUrls(ctx) {
-  const {
-    webClientIntorConfig,
-    defaultLocale,
-    webLocales: locales
-  } = ctx.constants;
-  return async function resolveUrls(locale) {
+  const { webClientIntorConfig } = ctx.constants;
+  const { defaultLocale } = webClientIntorConfig;
+  return async function resolveUrls(locale = defaultLocale) {
     const { pathname: rawPathname } = await readIntorUrlState();
     if (!rawPathname) throw new Error("[metadata] Missing x-intor-pathname");
     const canonicalPathname = localizePathname(
@@ -18,9 +15,7 @@ function createResolveUrls(ctx) {
     ).pathname;
     const alternates = buildAlternatePathnames({
       rawPathname,
-      webClientIntorConfig,
-      defaultLocale,
-      locales
+      webClientIntorConfig
     });
     return {
       canonical: canonicalPathname,

package/dist/src/web/server/seo/metadata/utils/build-og-image.js

@@ -17,8 +17,8 @@ const buildOgImages = ({
       secureUrl: secureUrl ?? void 0,
       alt: alt ?? void 0,
       type: type ?? validType,
-      width: typeof width === "number" && width > 0 ? width : 1200,
-      height: typeof height === "number" && height > 0 ? height : 630
+      width: typeof width === "number" && width > 0 ? width : void 0,
+      height: typeof height === "number" && height > 0 ? height : void 0
     }
   ];
 };

package/dist/src/web/server/seo/metadata/utils/ensure-og-type.js

@@ -1,14 +1,4 @@
-import 'mime-types';
-import 'sitero-domain';
 import { OG_TYPE_ARRAY } from '../../../../../shared/seo-metadata.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import 'zod';
 
 const ensureOgType = (fallback, ogType) => {
   if (typeof ogType !== "string") return fallback;

package/dist/src/web/server/seo/metadata/utils/ensure-twitter-card.js

@@ -1,14 +1,4 @@
-import 'mime-types';
-import 'sitero-domain';
 import { TWITTER_CARD_ARRAY } from '../../../../../shared/seo-metadata.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import 'zod';
 
 const ensureTwitterCard = (fallback, twitterCard) => {
   if (typeof twitterCard !== "string") return fallback;

package/dist/src/web/server/seo/metadata/utils/resolve-robots.js

@@ -0,0 +1,17 @@
+function resolveRobots(value, forceNoIndex = false) {
+  const directives = value?.trim();
+  if (!directives) {
+    return {
+      index: !forceNoIndex,
+      follow: true,
+      "max-image-preview": "large"
+    };
+  }
+  if (!forceNoIndex) return directives;
+  const preserved = directives.split(",").map((item) => item.trim()).filter(
+    (item) => item && !["index", "all", "noindex"].includes(item.toLowerCase())
+  );
+  return [...preserved, "noindex"].join(", ");
+}
+
+export { resolveRobots };

package/dist/src/web/server/seo/sitemap/build-entries.js

@@ -0,0 +1,47 @@
+import { buildAlternatePathnames } from '../metadata/build-alternate-pathnames.js';
+import { createBuildMetadata } from '../metadata/build-metadata.js';
+
+function createBuildSitemapEntries(ctx) {
+  const { webClientIntorConfig, siteConfig } = ctx.constants;
+  const buildMetadata = createBuildMetadata(ctx);
+  const base = new URL(siteConfig.site.url);
+  const absoluteUrl = (value) => {
+    if (typeof value !== "string" && !(value instanceof URL)) {
+      throw new Error("[sitemap] Expected a URL from the metadata builder");
+    }
+    return new URL(value, base);
+  };
+  return function buildEntries(pathname, seoSource, lastModified, isArticle = false) {
+    const alternates = buildAlternatePathnames({
+      rawPathname: pathname,
+      webClientIntorConfig
+    });
+    const entries = [];
+    for (const locale of webClientIntorConfig.supportedLocales) {
+      const metadata = buildMetadata(
+        { canonical: alternates[locale], alternates },
+        seoSource,
+        locale,
+        isArticle
+      );
+      const robots = metadata.robots;
+      const noindex = typeof robots === "string" ? /(?:^|,)\s*(?:noindex|none)\s*(?:,|$)/i.test(robots) : robots?.index === false;
+      if (noindex) continue;
+      const url = absoluteUrl(metadata.alternates?.canonical);
+      if (url.origin !== base.origin) continue;
+      const languages = Object.fromEntries(
+        Object.entries(metadata.alternates?.languages ?? {}).map(
+          ([language, href]) => [language, absoluteUrl(href).href]
+        )
+      );
+      entries.push({
+        url: url.href,
+        alternates: { languages },
+        ...lastModified ? { lastModified: new Date(lastModified) } : {}
+      });
+    }
+    return [...new Map(entries.map((entry) => [entry.url, entry])).values()];
+  };
+}
+
+export { createBuildSitemapEntries };

package/dist/src/web/server/seo/sitemap/build-urls-from-pathname.js

@@ -1,30 +1,15 @@
-import 'mime-types';
-import 'sitero-domain';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
 import { joinUrl } from '../../../../shared/utils/join-url.js';
-import 'zod';
 import { buildAlternatePathnames } from '../metadata/build-alternate-pathnames.js';
-import 'intor';
-import 'intor/next/server';
 
 function createBuildUrlsFromPathname({
   webClientIntorConfig,
-  webLocales: locales,
-  defaultLocale,
   webUrl
 }) {
+  const { defaultLocale } = webClientIntorConfig;
   return function buildUrlsFromPathname(pathname) {
     const alternates = buildAlternatePathnames({
       rawPathname: pathname,
-      webClientIntorConfig,
-      locales,
-      defaultLocale
+      webClientIntorConfig
     });
     const localizedMap = Object.fromEntries(
       Object.entries(alternates).map(([locale, path]) => [

package/dist/src/web/server/seo/sitemap/get-category-items.js

@@ -1,33 +1,31 @@
-import 'mime-types';
-import 'sitero-domain';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
+import { POST_TYPES } from 'sitero-domain';
 import { joinUrl } from '../../../../shared/utils/join-url.js';
-import 'zod';
+import { createBuildSitemapEntries } from './build-entries.js';
+import { loadSitemapCards, loadSitemapDetail } from './queries.js';
 
-function createGetCategoryItems({
-  loadCategories,
-  buildUrlsFromPathname
-}) {
+function createGetCategoryItems(ctx) {
+  const buildEntries = createBuildSitemapEntries(ctx);
   return async function getCategoryItems({ topicSlug }) {
-    const { categories } = await loadCategories({
-      locale: "",
-      // locale not important here
-      topicSlug
-    });
-    return categories.map((c) => {
-      const url = joinUrl("/", topicSlug, c.slug);
-      const entry = buildUrlsFromPathname(url);
-      return {
-        ...entry,
-        lastModified: new Date(c.updatedAt)
-      };
+    if (ctx.constants.forceNoIndex) return [];
+    const categories = await loadSitemapCards(ctx.findListCards, {
+      type: POST_TYPES.CATEGORY,
+      topicSlug,
+      locale: ctx.constants.webClientIntorConfig.defaultLocale
     });
+    const entries = [];
+    for (const card of categories) {
+      const category = await loadSitemapDetail(ctx.findDetail, { id: card.id });
+      if (!category?.isActive || category.type !== POST_TYPES.CATEGORY)
+        continue;
+      entries.push(
+        ...buildEntries(
+          joinUrl("/", topicSlug, category.slug),
+          category,
+          category.updatedAt
+        )
+      );
+    }
+    return [...new Map(entries.map((entry) => [entry.url, entry])).values()];
   };
 }
 

package/dist/src/web/server/seo/sitemap/get-page-items.js

@@ -1,18 +1,23 @@
-function createGetPageItems({
-  loadPage,
-  buildUrlsFromPathname
-}) {
+import { POST_TYPES } from 'sitero-domain';
+import { createBuildSitemapEntries } from './build-entries.js';
+import { loadSitemapDetail } from './queries.js';
+
+function createGetPageItems(ctx) {
+  const buildEntries = createBuildSitemapEntries(ctx);
   return async function getPageItems({ pages }) {
-    return await Promise.all(
-      Object.entries(pages).map(async ([key, { pathname }]) => {
-        const { page } = await loadPage({ pageSlug: key });
-        const entry = buildUrlsFromPathname(pathname);
-        return {
-          ...entry,
-          lastModified: page?.updatedAt ? new Date(page.updatedAt) : /* @__PURE__ */ new Date()
-        };
+    if (ctx.constants.forceNoIndex) return [];
+    const entries = await Promise.all(
+      Object.entries(pages).map(async ([pageSlug, { pathname }]) => {
+        const page = await loadSitemapDetail(ctx.findDetail, {
+          type: POST_TYPES.PAGE,
+          slug: pageSlug
+        });
+        return buildEntries(pathname, page, page?.updatedAt);
       })
     );
+    return [
+      ...new Map(entries.flat().map((entry) => [entry.url, entry])).values()
+    ];
   };
 }
 

package/dist/src/web/server/seo/sitemap/get-post-items.js

@@ -1,75 +1,57 @@
 import { POST_TYPES } from 'sitero-domain';
-import 'mime-types';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
 import { joinUrl } from '../../../../shared/utils/join-url.js';
-import 'zod';
+import { createBuildSitemapEntries } from './build-entries.js';
+import { loadSitemapCards, loadSitemapDetail } from './queries.js';
 
-function getCategorySlug(post) {
-  return post.parents?.[0]?.slug;
-}
-function getSubcategorySlugs(post) {
-  const subcategorySlug = post.parents?.[0]?.slug;
-  const categorySlug = post.parents?.[0]?.parents?.[0]?.slug;
-  return {
-    categorySlug,
-    subcategorySlug
-  };
-}
-function createGetPostItems({
-  loadPosts,
-  buildUrlsFromPathname
-}) {
+function createGetPostItems(ctx) {
+  const buildEntries = createBuildSitemapEntries(ctx);
   return async function getPostItems({
     topicSlug,
-    topics
+    routeMode
   }) {
-    const topic = topics?.[topicSlug];
-    const hasCategory = topic?.roles.includes(POST_TYPES.CATEGORY) ?? false;
-    const hasSubcategory = topic?.roles.includes(POST_TYPES.SUBCATEGORY) ?? false;
-    const { posts } = await loadPosts({
-      locale: "",
-      // locale not important here
+    if (ctx.constants.forceNoIndex) return [];
+    const cards = await loadSitemapCards(ctx.findListCards, {
+      type: POST_TYPES.POST,
       topicSlug,
-      include: hasSubcategory ? { parents: { include: { parents: true } } } : { parents: true }
+      locale: ctx.constants.webClientIntorConfig.defaultLocale
     });
-    return posts.filter((p) => {
-      if (!topic) return getCategorySlug(p);
-      if (!hasCategory) return true;
-      if (!hasSubcategory) return getCategorySlug(p);
-      const { categorySlug, subcategorySlug } = getSubcategorySlugs(p);
-      return categorySlug && subcategorySlug;
-    }).map((p) => {
-      const pathname = (() => {
-        if (!topic) {
-          return joinUrl("/", topicSlug, getCategorySlug(p) ?? "", p.slug);
+    const entries = [];
+    for (const card of cards) {
+      const post = await loadSitemapDetail(ctx.findDetail, { id: card.id });
+      if (!post || !post.isActive) continue;
+      let pathname = joinUrl("/", topicSlug, post.slug);
+      if (routeMode !== "flat") {
+        const parentId = post.parents[0]?.id;
+        if (!parentId) continue;
+        const parent = await loadSitemapDetail(ctx.findDetail, {
+          id: parentId
+        });
+        if (!parent || !parent.isActive || parent.topicId !== post.topicId)
+          continue;
+        if (routeMode === "category") {
+          if (parent.type !== POST_TYPES.CATEGORY) continue;
+          pathname = joinUrl("/", topicSlug, parent.slug, post.slug);
+        } else {
+          if (parent.type !== POST_TYPES.SUBCATEGORY) continue;
+          const categoryId = parent.parents[0]?.id;
+          if (!categoryId) continue;
+          const category = await loadSitemapDetail(ctx.findDetail, {
+            id: categoryId
+          });
+          if (!category || !category.isActive || category.type !== POST_TYPES.CATEGORY || category.topicId !== post.topicId)
+            continue;
+          pathname = joinUrl(
+            "/",
+            topicSlug,
+            category.slug,
+            parent.slug,
+            post.slug
+          );
         }
-        if (!hasCategory) {
-          return joinUrl("/", topicSlug, p.slug);
-        }
-        if (!hasSubcategory) {
-          return joinUrl("/", topicSlug, getCategorySlug(p) ?? "", p.slug);
-        }
-        const { categorySlug, subcategorySlug } = getSubcategorySlugs(p);
-        return joinUrl(
-          "/",
-          topicSlug,
-          categorySlug ?? "",
-          subcategorySlug ?? "",
-          p.slug
-        );
-      })();
-      const entry = buildUrlsFromPathname(pathname);
-      return {
-        ...entry,
-        lastModified: new Date(p.updatedAt)
-      };
-    });
+      }
+      entries.push(...buildEntries(pathname, post, post.updatedAt, true));
+    }
+    return [...new Map(entries.map((entry) => [entry.url, entry])).values()];
   };
 }
 

package/dist/src/web/server/seo/sitemap/get-subcategory-items.js

@@ -1,38 +1,42 @@
-import 'mime-types';
-import 'sitero-domain';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
+import { POST_TYPES } from 'sitero-domain';
 import { joinUrl } from '../../../../shared/utils/join-url.js';
-import 'zod';
+import { createBuildSitemapEntries } from './build-entries.js';
+import { loadSitemapCards, loadSitemapDetail } from './queries.js';
 
-function createGetSubcategoryItems({
-  loadSubcategories,
-  buildUrlsFromPathname
-}) {
+function createGetSubcategoryItems(ctx) {
+  const buildEntries = createBuildSitemapEntries(ctx);
   return async function getSubcategoryItems({
     topicSlug,
     categorySlug
   }) {
-    const { subcategories } = await loadSubcategories({
-      locale: "",
-      // locale not important here
+    if (ctx.constants.forceNoIndex) return [];
+    const cards = await loadSitemapCards(ctx.findListCards, {
+      type: POST_TYPES.SUBCATEGORY,
       topicSlug,
-      ...categorySlug && { categorySlug }
-    });
-    return subcategories.filter((s) => categorySlug || s.parents?.[0]?.slug).map((s) => {
-      const parentSlug = categorySlug ?? s.parents?.[0]?.slug ?? "";
-      const url = joinUrl("/", topicSlug, parentSlug, s.slug);
-      const entry = buildUrlsFromPathname(url);
-      return {
-        ...entry,
-        lastModified: new Date(s.updatedAt)
-      };
+      locale: ctx.constants.webClientIntorConfig.defaultLocale,
+      ...categorySlug ? { parentSlug: categorySlug } : {}
     });
+    const entries = [];
+    for (const card of cards) {
+      const subcategory = await loadSitemapDetail(ctx.findDetail, {
+        id: card.id
+      });
+      const categoryId = subcategory?.parents[0]?.id;
+      if (!subcategory?.isActive || !categoryId) continue;
+      const category = await loadSitemapDetail(ctx.findDetail, {
+        id: categoryId
+      });
+      if (!category || !category.isActive || category.type !== POST_TYPES.CATEGORY || category.topicId !== subcategory.topicId || categorySlug && category.slug !== categorySlug)
+        continue;
+      entries.push(
+        ...buildEntries(
+          joinUrl("/", topicSlug, category.slug, subcategory.slug),
+          subcategory,
+          subcategory.updatedAt
+        )
+      );
+    }
+    return [...new Map(entries.map((entry) => [entry.url, entry])).values()];
   };
 }