wpheadless-lib 1.1.10 → 1.1.12

package/dist/utils/language.js

@@ -0,0 +1,75 @@
+const normalizePath = (path) => {
+    if (!path || path === "/")
+        return "/";
+    const withLeadingSlash = path.startsWith("/") ? path : `/${path}`;
+    return withLeadingSlash.endsWith("/") ? withLeadingSlash : `${withLeadingSlash}/`;
+};
+const defaultSecondaryPath = (code) => normalizePath(code);
+export function normalizeLanguages(languages, options = {}) {
+    const fallbackCode = options.defaultCode || options.defaultLocale || "en";
+    const source = languages && languages.length > 0
+        ? languages
+        : [{ code: fallbackCode, locale: options.defaultLocale || fallbackCode }];
+    const explicitDefaultIndex = source.findIndex((language) => language.isDefault);
+    const defaultIndex = explicitDefaultIndex >= 0 ? explicitDefaultIndex : 0;
+    const isMulti = source.length > 1;
+    return source.map((language, index) => {
+        const isDefault = index === defaultIndex;
+        const code = language.code;
+        const basePath = language.basePath !== undefined
+            ? normalizePath(language.basePath)
+            : isMulti && !isDefault
+                ? defaultSecondaryPath(code)
+                : "/";
+        return {
+            ...language,
+            code,
+            locale: language.locale || code,
+            basePath: isDefault ? "/" : basePath,
+            isDefault,
+            prefixed: isMulti && !isDefault,
+        };
+    });
+}
+export function getLanguageMode(languages) {
+    return normalizeLanguages(languages).length > 1 ? "multi" : "single";
+}
+export function getDefaultLanguage(languages) {
+    return normalizeLanguages(languages).find((language) => language.isDefault) ?? normalizeLanguages(languages)[0];
+}
+export function getLanguageByCode(languages, code) {
+    const normalized = normalizeLanguages(languages);
+    if (!code)
+        return normalized.find((language) => language.isDefault) ?? normalized[0];
+    return normalized.find((language) => language.code === code || language.locale === code);
+}
+export function getLanguageBasePath(language, allLanguages) {
+    if (allLanguages) {
+        const normalized = normalizeLanguages(allLanguages);
+        const match = normalized.find((item) => item.code === language.code) ??
+            normalized.find((item) => item.locale === language.locale);
+        if (match)
+            return match.basePath;
+    }
+    return normalizeLanguages([language])[0].basePath;
+}
+export function shouldRenderLanguageAlternates(languages) {
+    return normalizeLanguages(languages).length > 1;
+}
+export function buildLanguagePath(language, path = "", allLanguages) {
+    const basePath = getLanguageBasePath(language, allLanguages);
+    const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+    return normalizePath(`${basePath}${normalizedPath}`);
+}
+export function getWpLanguageCode(language) {
+    return language?.wpLang;
+}
+export function getWpLanguageFilter(language) {
+    if (!language)
+        return {};
+    if (language.langId) {
+        return { taxonomies: { language: [language.langId] } };
+    }
+    const wpLang = getWpLanguageCode(language);
+    return wpLang ? { lang: wpLang } : {};
+}

package/dist/utils/seo.d.ts

@@ -20,11 +20,6 @@ type FeaturedMedia = {
     [key: string]: unknown;
 };
 type FeaturedMediaLike = Pick<FeaturedMedia, "source_url">;
-type YoastSchemaHolder = {
-    yoast_head_json?: {
-        schema?: unknown;
-    };
-};
 type YoastHolder = {
     yoast_head_json?: WPYoastHeadJson;
 };
@@ -46,7 +41,7 @@ export declare function rewriteYoastUrls<T extends WPYoastHeadJson | undefined>(
 export declare function getYoastHead(entity?: YoastHolder, opts?: RewriteOpts): WPYoastHeadJson | undefined;
 export declare function buildYoastRobotsMeta(robots?: WPYoastHeadJson["robots"]): Metadata["robots"] | undefined;
 export declare function isYoastNoindex(yoast?: WPYoastHeadJson): boolean;
-export declare function getYoastSchema(entity?: YoastSchemaHolder, opts?: RewriteOpts): unknown;
+export declare function getYoastSchema(entity?: unknown, opts?: RewriteOpts): unknown;
 export declare function stripBreadcrumbsFromSchema(schema: unknown): unknown;
 export declare function getFeaturedMedia(entity?: WithEmbeddedMedia): FeaturedMedia | undefined;
 export declare function getPlainTextExcerpt(html?: string, maxLength?: number): string | undefined;

package/dist/utils/seo.js

@@ -1,4 +1,4 @@
-import { stripTags } from "./html";
+import { stripTags, toPlainText } from "./html.js";
 export function getOgImageUrl(entity, featuredMedia) {
     const ogUrl = entity?.yoast_head_json?.og_image?.[0]?.url;
     return ogUrl || featuredMedia?.source_url;
@@ -196,10 +196,14 @@ export function getFeaturedMedia(entity) {
     return entity?._embedded?.["wp:featuredmedia"]?.[0];
 }
 export function getPlainTextExcerpt(html, maxLength = 160) {
-    if (!html)
-        return undefined;
-    const text = html.replace(/<[^>]*>/g, "");
-    return maxLength > 0 ? text.slice(0, maxLength) : text;
+    const text = toPlainText(html);
+    if (!text || maxLength <= 0 || text.length <= maxLength)
+        return text;
+    const truncated = text.slice(0, maxLength).trimEnd();
+    const lastSpace = truncated.lastIndexOf(" ");
+    return lastSpace > maxLength * 0.6
+        ? truncated.slice(0, lastSpace).trimEnd()
+        : truncated;
 }
 export function buildBreadcrumbSchema(items) {
     return {

package/dist/utils/sitemap.d.ts

@@ -1,4 +1,4 @@
-import type { LanguageConfig } from "./hreflang";
+import type { LanguageConfig } from "./hreflang.js";
 export type SitemapRuntimeConfig = {
     postsPerPagePagination: number;
 };

package/dist/utils/sitemap.js

@@ -1,28 +1,80 @@
 import { createPageEndpoints, createPostsEndpoints } from "wpjsapi-lib";
-import { createWpClient } from "../api/wpClient";
-import { listPostsWithEmbeds } from "../api/posts";
-import { getCategoryPaginationStaticParams } from "../base";
-import { getHomePaginationStaticParams } from "../base/home/pagination";
-import { getAbsoluteUrl, ensureTrailingSlash } from "./routing";
-import { isYoastNoindex } from "./seo";
-import { getTranslationKey, getEntityLanguageId, withXDefault, } from "./hreflang";
+import { createWpClient, isValidWpApiUrl } from "../api/wpClient.js";
+import { listPostsWithEmbeds } from "../api/posts.js";
+import { getCategoryPaginationStaticParams, getCategoryTotalPages, } from "../base/index.js";
+import { getHomePaginationStaticParams, getHomeTotalPages, } from "../base/home/pagination.js";
+import { getAbsoluteUrl, ensureTrailingSlash } from "./routing.js";
+import { isYoastNoindex } from "./seo.js";
+import { getHreflangCode, getTranslationKey, getEntityLanguageId, withXDefault, } from "./hreflang.js";
+import { normalizeLanguages, shouldRenderLanguageAlternates, } from "./language.js";
 const resolveWpApiUrl = (cfg) => cfg.wpApiUrl ?? process.env.WP_API_URL ?? "";
 const resolveSiteUrl = (cfg) => cfg.siteUrl ?? process.env.NEXT_PUBLIC_SITE_URL;
-const buildHomeAlternates = (cfg) => withXDefault(cfg.languages.reduce((acc, langCfg) => {
-    const basePath = ensureTrailingSlash(langCfg.basePath || "/");
-    acc[langCfg.code] = getAbsoluteUrl(basePath, resolveSiteUrl(cfg));
-    return acc;
-}, {}));
+const buildHomeAlternates = (cfg) => shouldRenderLanguageAlternates(cfg.languages)
+    ? withXDefault(normalizeLanguages(cfg.languages).reduce((acc, langCfg) => {
+        const basePath = ensureTrailingSlash(langCfg.basePath || "/");
+        acc[getHreflangCode(langCfg)] = getAbsoluteUrl(basePath, resolveSiteUrl(cfg));
+        return acc;
+    }, {}))
+    : undefined;
+async function buildHomePaginationAlternates(cfg, currentPage) {
+    if (!shouldRenderLanguageAlternates(cfg.languages))
+        return undefined;
+    const wpApiUrl = resolveWpApiUrl(cfg);
+    if (!isValidWpApiUrl(wpApiUrl))
+        return undefined;
+    const siteUrl = resolveSiteUrl(cfg);
+    const alternates = {};
+    for (const langCfg of normalizeLanguages(cfg.languages)) {
+        const totalPages = await getHomeTotalPages({
+            baseApiUrl: wpApiUrl,
+            perPage: cfg.runtimeConfig.postsPerPagePagination,
+            langId: langCfg.langId,
+        });
+        if (totalPages < currentPage)
+            continue;
+        const basePath = ensureTrailingSlash(langCfg.basePath || "/");
+        alternates[getHreflangCode(langCfg)] = getAbsoluteUrl(`${basePath}page/${currentPage}/`, siteUrl);
+    }
+    return withXDefault(alternates);
+}
+const escapeXml = (value) => value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+const renderAlternates = (alternates) => {
+    const normalizedAlternates = withXDefault(alternates);
+    if (!normalizedAlternates)
+        return undefined;
+    return Object.entries(normalizedAlternates)
+        .map(([code, href]) => `<xhtml:link rel="alternate" hreflang="${escapeXml(code)}" href="${escapeXml(href)}" />`)
+        .join("");
+};
 const getYoastHeadJson = (entity) => entity.yoast_head_json;
 const isNoindexEntity = (entity) => isYoastNoindex(getYoastHeadJson(entity));
+const getWpLangParam = (language) => {
+    const lang = language.wpLang || (language.langId ? language.code : undefined);
+    return lang ? { lang } : {};
+};
+async function mapConcurrent(items, mapper, concurrency = 5) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+    return results;
+}
 export function renderSitemap(entries) {
     const items = entries
         .map((entry) => {
-        const links = entry.alternates &&
-            Object.entries(entry.alternates)
-                .map(([code, href]) => `<xhtml:link rel="alternate" hreflang="${code}" href="${href}" />`)
-                .join("");
-        return `<url><loc>${entry.url}</loc>${entry.lastmod ? `<lastmod>${entry.lastmod}</lastmod>` : ""}${links ?? ""}</url>`;
+        const links = renderAlternates(entry.alternates);
+        return `<url><loc>${escapeXml(entry.url)}</loc>${entry.lastmod ? `<lastmod>${escapeXml(entry.lastmod)}</lastmod>` : ""}${links ?? ""}</url>`;
     })
         .join("");
     return (`<?xml version="1.0" encoding="UTF-8"?>` +
@@ -32,7 +84,7 @@ export function renderSitemap(entries) {
 }
 export function renderSitemapIndex(sitemaps) {
     const items = sitemaps
-        .map((s) => `<sitemap><loc>${s.url}</loc>${s.lastmod ? `<lastmod>${s.lastmod}</lastmod>` : ""}</sitemap>`)
+        .map((s) => `<sitemap><loc>${escapeXml(s.url)}</loc>${s.lastmod ? `<lastmod>${escapeXml(s.lastmod)}</lastmod>` : ""}</sitemap>`)
         .join("");
     return (`<?xml version="1.0" encoding="UTF-8"?>` +
         `<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">` +
@@ -40,38 +92,42 @@ export function renderSitemapIndex(sitemaps) {
         `</sitemapindex>`);
 }
 export async function getHomeEntries(cfg) {
-    const entries = [];
-    const { languages, runtimeConfig } = cfg;
+    const { runtimeConfig } = cfg;
+    const languages = normalizeLanguages(cfg.languages);
     const wpApiUrl = resolveWpApiUrl(cfg);
     const siteUrl = resolveSiteUrl(cfg);
     const homeAlternates = buildHomeAlternates(cfg);
-    for (const langCfg of languages) {
+    return mapConcurrent(languages, async (langCfg) => {
         const basePath = ensureTrailingSlash(langCfg.basePath || "/");
         const homeUrl = getAbsoluteUrl(basePath, siteUrl);
-        const homePosts = await listPostsWithEmbeds({
-            baseApiUrl: wpApiUrl,
-            perPage: runtimeConfig.postsPerPagePagination,
-            page: 1,
-            langId: langCfg.langId,
-            orderby: "date",
-            order: "desc",
-        });
-        const latest = homePosts.ok ? homePosts.data?.items[0] : undefined;
+        const homePosts = isValidWpApiUrl(wpApiUrl)
+            ? await listPostsWithEmbeds({
+                baseApiUrl: wpApiUrl,
+                perPage: runtimeConfig.postsPerPagePagination,
+                page: 1,
+                langId: langCfg.langId,
+                orderby: "date",
+                order: "desc",
+            })
+            : null;
+        const latest = homePosts?.ok ? homePosts.data?.items[0] : undefined;
         const lastmod = latest?.modified ||
             latest?.date;
-        entries.push({
+        return {
             url: homeUrl,
             lastmod: lastmod ? new Date(lastmod).toISOString() : undefined,
             alternates: homeAlternates ?? undefined,
-        });
-    }
-    return entries;
+        };
+    });
 }
 export async function getHomePaginationEntries(cfg) {
     const entries = [];
-    const { languages, runtimeConfig } = cfg;
+    const { runtimeConfig } = cfg;
+    const languages = normalizeLanguages(cfg.languages);
     const wpApiUrl = resolveWpApiUrl(cfg);
     const siteUrl = resolveSiteUrl(cfg);
+    if (!isValidWpApiUrl(wpApiUrl))
+        return entries;
     for (const langCfg of languages) {
         const basePath = ensureTrailingSlash(langCfg.basePath || "/");
         const pages = await getHomePaginationStaticParams({
@@ -79,7 +135,7 @@ export async function getHomePaginationEntries(cfg) {
             perPage: runtimeConfig.postsPerPagePagination,
             langId: langCfg.langId,
         });
-        for (const p of pages) {
+        const pageEntries = await mapConcurrent(pages, async (p) => {
             const url = getAbsoluteUrl(`${basePath}page/${p.page}/`, siteUrl);
             const pagePosts = await listPostsWithEmbeds({
                 baseApiUrl: wpApiUrl,
@@ -92,31 +148,39 @@ export async function getHomePaginationEntries(cfg) {
             const latest = pagePosts.ok ? pagePosts.data?.items[0] : undefined;
             const lastmod = latest?.modified ||
                 latest?.date;
-            entries.push({
+            return {
                 url,
                 lastmod: lastmod ? new Date(lastmod).toISOString() : undefined,
-            });
-        }
+                alternates: await buildHomePaginationAlternates(cfg, Number(p.page)),
+            };
+        });
+        entries.push(...pageEntries);
     }
     return entries;
 }
 export async function getCategoryEntries(cfg) {
     const entries = [];
-    const { languages, runtimeConfig } = cfg;
+    const { runtimeConfig } = cfg;
+    const languages = normalizeLanguages(cfg.languages);
     const wpApiUrl = resolveWpApiUrl(cfg);
     const siteUrl = resolveSiteUrl(cfg);
+    if (!isValidWpApiUrl(wpApiUrl))
+        return entries;
+    const renderAlternatesForLanguages = shouldRenderLanguageAlternates(cfg.languages);
     const categoriesPerLang = {};
     const categoryAlternates = {};
     for (const langCfg of languages) {
         const { categoriesApi } = createWpClient({ baseUrl: wpApiUrl });
         const categories = await categoriesApi.listAll({
-            ...(langCfg.langId ? { lang: langCfg.code } : {}),
+            ...getWpLangParam(langCfg),
             _fields: ["id", "slug", "name", "description", "meta", "yoast_head_json"],
         });
         const indexableCategories = categories.filter((cat) => !isNoindexEntity(cat));
         categoriesPerLang[langCfg.code] = indexableCategories;
         const basePath = ensureTrailingSlash(langCfg.basePath || "/");
         for (const cat of indexableCategories) {
+            if (!renderAlternatesForLanguages)
+                continue;
             const translationKey = getTranslationKey(cat);
             if (!translationKey)
                 continue;
@@ -124,13 +188,13 @@ export async function getCategoryEntries(cfg) {
             if (!categoryAlternates[translationKey]) {
                 categoryAlternates[translationKey] = {};
             }
-            categoryAlternates[translationKey][langCfg.code] = url;
+            categoryAlternates[translationKey][getHreflangCode(langCfg)] = url;
         }
     }
     for (const langCfg of languages) {
         const basePath = ensureTrailingSlash(langCfg.basePath || "/");
         const categories = categoriesPerLang[langCfg.code] ?? [];
-        for (const cat of categories) {
+        const categoryEntries = await mapConcurrent(categories, async (cat) => {
             const url = getAbsoluteUrl(`${basePath}${cat.slug}/`, siteUrl);
             const catPosts = await listPostsWithEmbeds({
                 baseApiUrl: wpApiUrl,
@@ -145,49 +209,84 @@ export async function getCategoryEntries(cfg) {
             const lastmod = latest?.modified ||
                 latest?.date;
             const alt = (() => {
+                if (!renderAlternatesForLanguages)
+                    return undefined;
                 const key = getTranslationKey(cat);
                 if (!key)
                     return undefined;
                 const a = withXDefault(categoryAlternates[key]);
                 return a;
             })();
-            entries.push({
+            return {
                 url,
                 lastmod: lastmod ? new Date(lastmod).toISOString() : undefined,
                 alternates: alt,
-            });
-        }
+            };
+        });
+        entries.push(...categoryEntries);
     }
     return entries;
 }
 export async function getCategoryPaginationEntries(cfg) {
     const entries = [];
-    const { languages, runtimeConfig } = cfg;
+    const { runtimeConfig } = cfg;
+    const languages = normalizeLanguages(cfg.languages);
     const wpApiUrl = resolveWpApiUrl(cfg);
     const siteUrl = resolveSiteUrl(cfg);
+    if (!isValidWpApiUrl(wpApiUrl))
+        return entries;
+    const renderAlternatesForLanguages = shouldRenderLanguageAlternates(cfg.languages);
     const catIdsBySlugByLang = {};
+    const catsBySlugByLang = {};
+    const alternatesByTranslationPage = {};
     for (const langCfg of languages) {
         const { categoriesApi } = createWpClient({ baseUrl: wpApiUrl });
         const categories = await categoriesApi.listAll({
-            lang: langCfg.code,
-            _fields: ["id", "slug", "yoast_head_json"],
+            ...getWpLangParam(langCfg),
+            _fields: ["id", "slug", "meta", "yoast_head_json"],
         });
         const indexableCategories = categories.filter((cat) => !isNoindexEntity(cat));
         catIdsBySlugByLang[langCfg.code] = Object.fromEntries(indexableCategories.map((c) => [c.slug, c.id]));
+        catsBySlugByLang[langCfg.code] = Object.fromEntries(indexableCategories.map((c) => [c.slug, c]));
+        const basePath = ensureTrailingSlash(langCfg.basePath || "/");
+        for (const category of indexableCategories) {
+            if (!renderAlternatesForLanguages)
+                continue;
+            const translationKey = getTranslationKey(category);
+            if (!translationKey)
+                continue;
+            const totalPages = await getCategoryTotalPages({
+                baseApiUrl: wpApiUrl,
+                categoryId: category.id,
+                perPage: runtimeConfig.postsPerPagePagination,
+                langId: langCfg.langId,
+            });
+            for (let page = 2; page <= totalPages; page++) {
+                const pageKey = String(page);
+                if (!alternatesByTranslationPage[translationKey]) {
+                    alternatesByTranslationPage[translationKey] = {};
+                }
+                if (!alternatesByTranslationPage[translationKey][pageKey]) {
+                    alternatesByTranslationPage[translationKey][pageKey] = {};
+                }
+                alternatesByTranslationPage[translationKey][pageKey][getHreflangCode(langCfg)] = getAbsoluteUrl(`${basePath}${category.slug}/page/${page}/`, siteUrl);
+            }
+        }
     }
     for (const langCfg of languages) {
         const catPages = await getCategoryPaginationStaticParams({
             baseApiUrl: wpApiUrl,
             perPage: runtimeConfig.postsPerPagePagination,
-            lang: langCfg.code,
+            lang: langCfg.wpLang || (langCfg.langId ? langCfg.code : undefined) || "",
             langId: langCfg.langId,
         });
         const basePath = ensureTrailingSlash(langCfg.basePath || "/");
-        for (const page of catPages) {
+        const pageEntries = await mapConcurrent(catPages, async (page) => {
             const url = getAbsoluteUrl(`${basePath}${page.category}/page/${page.page}/`, siteUrl);
             const catId = catIdsBySlugByLang[langCfg.code]?.[page.category];
             if (!catId)
-                continue;
+                return null;
+            const category = catsBySlugByLang[langCfg.code]?.[page.category];
             let lastmod;
             const pagePosts = await listPostsWithEmbeds({
                 baseApiUrl: wpApiUrl,
@@ -202,22 +301,29 @@ export async function getCategoryPaginationEntries(cfg) {
             lastmod =
                 latest?.modified ||
                     latest?.date;
-            entries.push({
+            return {
                 url,
                 lastmod: lastmod ? new Date(lastmod).toISOString() : undefined,
-            });
-        }
+                alternates: renderAlternatesForLanguages && category
+                    ? withXDefault(alternatesByTranslationPage[getTranslationKey(category) || ""]?.[page.page])
+                    : undefined,
+            };
+        });
+        entries.push(...pageEntries.filter(Boolean));
     }
     return entries;
 }
 export async function getPostEntriesForLang(langCode, cfg) {
-    const { languages } = cfg;
+    const languages = normalizeLanguages(cfg.languages);
     const langCfg = languages.find((l) => l.code === langCode);
     if (!langCfg)
         return [];
     const wpApiUrl = resolveWpApiUrl(cfg);
+    if (!isValidWpApiUrl(wpApiUrl))
+        return [];
     const siteUrl = resolveSiteUrl(cfg);
     const postsApi = createPostsEndpoints({ baseUrl: wpApiUrl });
+    const renderAlternatesForLanguages = shouldRenderLanguageAlternates(cfg.languages);
     const languageFilter = langCfg.langId
         ? { taxonomies: { language: [langCfg.langId] } }
         : {};
@@ -228,7 +334,7 @@ export async function getPostEntriesForLang(langCode, cfg) {
     });
     const indexablePosts = posts.filter((post) => !isNoindexEntity(post));
     const postAlternates = {};
-    for (const l of languages) {
+    const postsByLanguage = await mapConcurrent(languages, async (l) => {
         const base = ensureTrailingSlash(l.basePath || "/");
         const langPosts = l.code === langCfg.code
             ? indexablePosts
@@ -240,7 +346,12 @@ export async function getPostEntriesForLang(langCode, cfg) {
         const filteredLangPosts = l.code === langCfg.code
             ? langPosts
             : langPosts.filter((post) => !isNoindexEntity(post));
+        return { language: l, base, posts: filteredLangPosts };
+    });
+    for (const { language: l, base, posts: filteredLangPosts } of postsByLanguage) {
         for (const p of filteredLangPosts) {
+            if (!renderAlternatesForLanguages)
+                continue;
             const translationKey = getTranslationKey(p);
             if (!translationKey)
                 continue;
@@ -251,7 +362,7 @@ export async function getPostEntriesForLang(langCode, cfg) {
             const url = getAbsoluteUrl(`${base}${categorySlug}/${p.slug}/`, siteUrl);
             if (!postAlternates[translationKey])
                 postAlternates[translationKey] = {};
-            postAlternates[translationKey][l.code] = url;
+            postAlternates[translationKey][getHreflangCode(l)] = url;
         }
     }
     const basePath = ensureTrailingSlash(langCfg.basePath || "/");
@@ -265,7 +376,7 @@ export async function getPostEntriesForLang(langCode, cfg) {
         const lastmod = p.modified ||
             p.date;
         const translationKey = getTranslationKey(p);
-        const alts = translationKey
+        const alts = renderAlternatesForLanguages && translationKey
             ? withXDefault(postAlternates[translationKey])
             : undefined;
         return {
@@ -278,9 +389,12 @@ export async function getPostEntriesForLang(langCode, cfg) {
 }
 export async function getLegalEntries(cfg) {
     const entries = [];
-    const { languages } = cfg;
+    const languages = normalizeLanguages(cfg.languages);
     const siteUrl = resolveSiteUrl(cfg);
     const wpApiUrl = resolveWpApiUrl(cfg);
+    if (!isValidWpApiUrl(wpApiUrl))
+        return entries;
+    const renderAlternatesForLanguages = shouldRenderLanguageAlternates(cfg.languages);
     const pagesApi = createPageEndpoints({ baseUrl: wpApiUrl });
     const pagesPerLang = {};
     const alternatesByKey = {};
@@ -306,18 +420,22 @@ export async function getLegalEntries(cfg) {
                 "yoast_head_json",
             ],
         });
-        const filtered = pages.filter((p) => getEntityLanguageId(p)?.toString() === langCfg.langId?.toString());
+        const filtered = langCfg.langId
+            ? pages.filter((p) => getEntityLanguageId(p)?.toString() === langCfg.langId?.toString())
+            : pages;
         const indexablePages = filtered.filter((page) => !isNoindexEntity(page));
         pagesPerLang[langCfg.code] = indexablePages;
         const basePath = ensureTrailingSlash(langCfg.basePath || "/");
         for (const p of indexablePages) {
+            if (!renderAlternatesForLanguages)
+                continue;
             const translationKey = getTranslationKey(p);
             if (!translationKey)
                 continue;
             const url = getAbsoluteUrl(`${basePath}legal/${p.slug}/`, siteUrl);
             if (!alternatesByKey[translationKey])
                 alternatesByKey[translationKey] = {};
-            alternatesByKey[translationKey][langCfg.code] = url;
+            alternatesByKey[translationKey][getHreflangCode(langCfg)] = url;
         }
     }
     for (const langCfg of languages) {
@@ -327,7 +445,7 @@ export async function getLegalEntries(cfg) {
             const url = getAbsoluteUrl(`${basePath}legal/${p.slug}/`, siteUrl);
             const lastmod = p.modified || p.date;
             const translationKey = getTranslationKey(p);
-            const alts = translationKey
+            const alts = renderAlternatesForLanguages && translationKey
                 ? withXDefault(alternatesByKey[translationKey])
                 : undefined;
             entries.push({

package/dist/views/CategoryListView/index.d.ts

@@ -1,5 +1,5 @@
 import { type WPCategory, type WPPost } from "wpjsapi-lib";
-import { type Locale } from "../../utils";
+import { type Locale } from "../../utils/index.js";
 type CategoryListViewProps = {
     category: WPCategory;
     posts: WPPost[];
@@ -10,5 +10,5 @@ type CategoryListViewProps = {
     locale?: Locale;
     dateLocale?: string;
 };
-export declare function CategoryListView({ category, posts, totalPages, baseUrl, homeHref, linkBasePath, locale, dateLocale, }: CategoryListViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function CategoryListView({ category, posts, totalPages, baseUrl, homeHref, linkBasePath, locale, dateLocale, }: CategoryListViewProps): import("react").JSX.Element;
 export {};

package/dist/views/CategoryListView/index.js

@@ -1,16 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import Paginator from "../../components/Paginator";
-import PostCard from "../../components/PostCard";
+import Paginator from "../../components/Paginator/index.js";
+import PostCard from "../../components/PostCard/index.js";
 import styles from "./index.module.css";
-import { getCountLabel, getEmptyLabel, getPaginatorBase } from "./index.utils";
-import { Breadcrumbs } from "../../components";
-import { getTranslator } from "../../utils";
+import { getCountLabel, getEmptyLabel, getPaginatorBase } from "./index.utils.js";
+import { Breadcrumbs, JsonLd } from "../../components/index.js";
+import { getTranslator, getYoastSchema } from "../../utils/index.js";
 export function CategoryListView({ category, posts, totalPages, baseUrl, homeHref = "/", linkBasePath, locale, dateLocale = "en-US", }) {
     const paginatorBase = getPaginatorBase(category, baseUrl);
     const countLabel = getCountLabel(category, locale);
     const emptyLabel = getEmptyLabel(locale);
     const t = getTranslator(locale);
-    return (_jsxs("div", { className: `container ${styles.container}`, children: [_jsxs("header", { className: styles.header, children: [_jsx(Breadcrumbs, { items: [
+    return (_jsxs("div", { className: styles.container, children: [_jsx(JsonLd, { data: getYoastSchema(category) }), _jsxs("header", { className: styles.header, children: [_jsx(Breadcrumbs, { items: [
                             { label: "Home", href: homeHref },
                             { label: category.name },
                         ] }), _jsx("h1", { className: styles.title, children: category.name }), category.description && (_jsx("div", { className: styles.description, dangerouslySetInnerHTML: { __html: category.description } })), countLabel && _jsx("p", { className: styles.count, children: countLabel })] }), posts.length === 0 ? (_jsx("p", { className: styles.empty, children: emptyLabel })) : (_jsxs("section", { "aria-label": t("home.title"), className: styles.gridSection, children: [_jsx("div", { className: styles.grid, children: posts.map((post) => (_jsx(PostCard, { post: post, categorySlug: category.slug, basePath: linkBasePath, locale: locale, dateLocale: dateLocale }, post.id))) }), _jsx(Paginator, { currentPage: 1, totalPages: totalPages, baseUrl: paginatorBase, locale: locale })] }))] }));

package/dist/views/CategoryListView/index.utils.d.ts

@@ -1,5 +1,5 @@
 import { type WPCategory } from "wpjsapi-lib";
-import { type Locale } from "../../utils";
+import { type Locale } from "../../utils/index.js";
 export declare const getPaginatorBase: (category: WPCategory, baseUrl?: string) => string;
 export declare const getCountLabel: (category: WPCategory, locale?: Locale) => string | null;
 export declare const getEmptyLabel: (locale?: Locale) => string;

package/dist/views/CategoryListView/index.utils.js

@@ -1,4 +1,4 @@
-import { getTranslator } from "../../utils";
+import { getTranslator } from "../../utils/index.js";
 export const getPaginatorBase = (category, baseUrl) => baseUrl ?? `/${category.slug}`;
 export const getCountLabel = (category, locale) => {
     const t = getTranslator(locale);

package/dist/views/CategoryPaginationView/index.d.ts

@@ -1,5 +1,5 @@
 import { type WPCategory, type WPPost } from "wpjsapi-lib";
-import { type Locale } from "../../utils";
+import { type Locale } from "../../utils/index.js";
 type CategoryPaginationViewProps = {
     category: WPCategory;
     posts: WPPost[];
@@ -10,5 +10,5 @@ type CategoryPaginationViewProps = {
     locale?: Locale;
     dateLocale?: string;
 };
-export declare function CategoryPaginationView({ category, posts, currentPage, totalPages, baseUrl, linkBasePath, locale, dateLocale, }: CategoryPaginationViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function CategoryPaginationView({ category, posts, currentPage, totalPages, baseUrl, linkBasePath, locale, dateLocale, }: CategoryPaginationViewProps): import("react").JSX.Element;
 export {};