wpheadless-lib 1.0.0

package/dist/app/globals.css

@@ -0,0 +1,326 @@
+:root {
+  /* Spacing */
+  --container-width: 1200px;
+  --spacing-xs: 0.5rem;
+  --spacing-sm: 1rem;
+  --spacing-md: 1.5rem;
+  --spacing-lg: 2rem;
+  --spacing-xl: 3rem;
+
+  /* Typography */
+  --font-sans: -apple-system, BlinkMacSystemFont, "Segoe UI", "Inter", "Roboto",
+    "Helvetica Neue", Arial, sans-serif;
+  --font-display: "Inter", -apple-system, BlinkMacSystemFont, sans-serif;
+
+  /* Transitions */
+  --transition: all 0.2s ease;
+
+  /* Colors - Light theme (default) */
+  --primary: #2563eb;
+  --primary-hover: #1d4ed8;
+  --secondary: #64748b;
+  --background: #ffffff;
+  --background-alt: #f8fafc;
+  --foreground: #0f172a;
+  --foreground-light: #475569;
+  --border: #e2e8f0;
+  --card-bg: #ffffff;
+  --shadow: rgba(0, 0, 0, 0.05);
+  --shadow-hover: rgba(0, 0, 0, 0.1);
+}
+
+/* Dark theme via data attribute (higher priority) */
+:root[data-theme="dark"] {
+  --background: #0f172a;
+  --background-alt: #1e293b;
+  --foreground: #f1f5f9;
+  --foreground-light: #cbd5e1;
+  --border: #334155;
+  --card-bg: #1e293b;
+  --shadow: rgba(0, 0, 0, 0.3);
+  --shadow-hover: rgba(0, 0, 0, 0.5);
+}
+
+/* Dark theme via system preference (lower priority) */
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme]) {
+    --background: #0f172a;
+    --background-alt: #1e293b;
+    --foreground: #f1f5f9;
+    --foreground-light: #cbd5e1;
+    --border: #334155;
+    --card-bg: #1e293b;
+    --shadow: rgba(0, 0, 0, 0.3);
+    --shadow-hover: rgba(0, 0, 0, 0.5);
+  }
+}
+
+* {
+  box-sizing: border-box;
+  padding: 0;
+  margin: 0;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+html,
+body {
+  max-width: 100vw;
+  overflow-x: hidden;
+}
+
+body {
+  color: var(--foreground);
+  background: var(--background);
+  font-family: var(--font-sans);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  line-height: 1.6;
+}
+
+/* Typography */
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-family: var(--font-display);
+  font-weight: 700;
+  line-height: 1.2;
+  color: var(--foreground);
+  margin-bottom: 0.75rem;
+}
+
+h1 {
+  font-size: clamp(1.75rem, 4vw, 2.5rem);
+  margin-bottom: 1rem;
+}
+h2 {
+  font-size: clamp(1.5rem, 3vw, 2rem);
+  margin-top: 2rem;
+}
+h3 {
+  font-size: clamp(1.25rem, 2.5vw, 1.5rem);
+  margin-top: 1.5rem;
+}
+
+p {
+  margin-bottom: 1rem;
+  line-height: 1.7;
+}
+
+a {
+  color: var(--primary);
+  text-decoration: none;
+  transition: var(--transition);
+}
+
+a:hover {
+  color: var(--primary-hover);
+}
+
+/* Post content styling */
+.post-content h2 {
+  margin-top: 2.5rem;
+  margin-bottom: 1rem;
+}
+
+.post-content h3 {
+  margin-top: 2rem;
+  margin-bottom: 0.875rem;
+}
+
+.post-content h4,
+.post-content h5,
+.post-content h6 {
+  margin-top: 1.5rem;
+  margin-bottom: 0.75rem;
+}
+
+.post-content p {
+  margin-bottom: 1.5rem;
+}
+
+.post-content ul,
+.post-content ol {
+  margin-bottom: 1.5rem;
+  padding-left: 1.5rem;
+}
+
+.post-content li {
+  margin-bottom: 0.5rem;
+}
+
+.post-content blockquote {
+  margin: 2rem 0;
+  padding-left: 1.5rem;
+  border-left: 4px solid var(--primary);
+  color: var(--foreground-light);
+  font-style: italic;
+}
+
+.post-content img {
+  display: block;
+  margin: 2rem auto;
+  max-width: 100%;
+  height: auto;
+  border-radius: 8px;
+}
+
+.post-content figure {
+  max-width: 100% !important;
+  width: auto !important;
+  margin: 2rem auto;
+  text-align: center;
+}
+
+.post-content figure img {
+  margin: 0 auto;
+}
+
+.post-content figcaption {
+  margin-top: 0.75rem;
+  font-size: 0.875rem;
+  color: var(--foreground-light);
+  font-style: italic;
+}
+
+.post-content pre {
+  margin: 1.5rem 0;
+  padding: 1rem;
+  background: var(--background-alt);
+  border-radius: 8px;
+  overflow-x: auto;
+}
+
+/* Container */
+.container {
+  width: 100%;
+  max-width: var(--container-width);
+  margin: 0 auto;
+  padding: 0 var(--spacing-md);
+}
+
+/* Card styling */
+.card {
+  background: var(--card-bg);
+  border-radius: 12px;
+  overflow: hidden;
+  box-shadow: 0 1px 3px var(--shadow);
+  transition: var(--transition);
+}
+
+.card:hover {
+  box-shadow: 0 10px 25px var(--shadow-hover);
+  transform: translateY(-2px);
+}
+
+/* Badge */
+.badge {
+  display: inline-block;
+  padding: 0.25rem 0.75rem;
+  background: var(--primary);
+  color: white;
+  font-size: 0.75rem;
+  font-weight: 600;
+  border-radius: 9999px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+/* Utilities */
+.text-muted {
+  color: var(--foreground-light);
+}
+
+a {
+  text-decoration: none;
+}
+
+a.header-link {
+  color: var(--foreground);
+  font-weight: 600;
+  font-size: 0.9375rem;
+  transition: var(--transition);
+  position: relative;
+  display: inline-block;
+}
+
+a.header-link::after {
+  content: "";
+  position: absolute;
+  bottom: -4px;
+  left: 0;
+  width: 0;
+  height: 2px;
+  background: var(--primary);
+  transition: width 0.3s ease;
+}
+
+a.header-link:hover {
+  color: var(--primary);
+}
+
+a.header-link:hover::after {
+  width: 100%;
+}
+
+a.footer-link {
+  color: var(--foreground-light);
+  font-size: 0.875rem;
+  transition: var(--transition);
+  display: inline-block;
+}
+
+a.footer-link:hover {
+  color: var(--primary);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme]) {
+    color-scheme: dark;
+  }
+}
+
+:root[data-theme="dark"] {
+  color-scheme: dark;
+}
+
+/* Paginator styles */
+.paginator-nav,
+.paginator-page {
+  padding: 0.625rem 1.25rem;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--card-bg);
+  color: var(--foreground);
+  font-weight: 500;
+  font-size: 0.9375rem;
+  transition: var(--transition);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 44px;
+}
+
+.paginator-nav:hover,
+.paginator-page:hover {
+  border-color: var(--primary);
+  background: var(--background-alt);
+  color: var(--primary);
+}
+
+.paginator-page.paginator-active {
+  background: var(--primary);
+  color: white;
+  border-color: var(--primary);
+  font-weight: 600;
+}
+
+.paginator-page.paginator-active:hover {
+  background: var(--primary-hover);
+  color: white;
+}

package/dist/base/category/index.d.ts

@@ -0,0 +1,38 @@
+import { type WPCategory, type WPPost } from "wpjsapi-lib";
+import type { Metadata } from "next";
+type CategoryStaticParamsInput = {
+    baseApiUrl: string;
+    lang: string;
+};
+export declare function getCategoryStaticParams({ baseApiUrl, lang, }: CategoryStaticParamsInput): Promise<Array<{
+    category: string;
+}>>;
+export declare function fetchCategory({ baseApiUrl, slug, lang, }: {
+    baseApiUrl: string;
+    slug: string;
+    lang: string;
+}): Promise<WPCategory | null>;
+export declare function fetchCategoryPosts({ baseApiUrl, categoryId, perPage, langId, }: {
+    baseApiUrl: string;
+    categoryId: number;
+    perPage: number;
+    langId: string;
+}): Promise<{
+    posts: WPPost[];
+    totalPages: number;
+}>;
+export declare function fetchCategoryByTranslationKey({ baseApiUrl, translationKey, lang, }: {
+    baseApiUrl: string;
+    translationKey: string;
+    lang: string;
+}): Promise<WPCategory | null>;
+export declare function buildCategoryMetadata({ category, canonical, useYoast, siteName, languages, siteUrl, wpApiUrl, }: {
+    category: WPCategory;
+    canonical: string;
+    useYoast?: boolean;
+    siteName?: string;
+    languages?: Record<string, string>;
+    siteUrl?: string;
+    wpApiUrl?: string;
+}): Metadata;
+export {};

package/dist/base/category/index.js

@@ -0,0 +1,104 @@
+import { getPlainTextExcerpt } from "../../utils";
+import { withXDefault } from "../../utils/hreflang";
+import { extractYoastMetadata } from "../../plugins/yoast";
+import { getCategoryByTranslationKey, getCategoryBySlug, listCategoryPosts, listCategoryStaticParams, } from "../../api/categories";
+export async function getCategoryStaticParams({ baseApiUrl, lang, }) {
+    const result = await listCategoryStaticParams({
+        baseApiUrl,
+        lang,
+    });
+    if (!result.ok || !result.data) {
+        if (result.error) {
+            console.error("Error generando rutas estáticas de categorías:", result.error);
+        }
+        return [];
+    }
+    return result.data;
+}
+export async function fetchCategory({ baseApiUrl, slug, lang, }) {
+    const result = await getCategoryBySlug({
+        baseApiUrl,
+        slug,
+        lang,
+    });
+    if (!result.ok) {
+        if (result.error)
+            console.error("Error obteniendo categoría:", result.error);
+        return null;
+    }
+    return result.data;
+}
+export async function fetchCategoryPosts({ baseApiUrl, categoryId, perPage, langId, }) {
+    const result = await listCategoryPosts({
+        baseApiUrl,
+        categoryId,
+        perPage,
+        langId,
+    });
+    if (!result.ok || !result.data) {
+        if (result.error)
+            console.error("Error obteniendo posts de la categoría:", result.error);
+        return { posts: [], totalPages: 0 };
+    }
+    return result.data;
+}
+export async function fetchCategoryByTranslationKey({ baseApiUrl, translationKey, lang, }) {
+    const result = await getCategoryByTranslationKey({
+        baseApiUrl,
+        translationKey,
+        lang,
+    });
+    if (!result.ok) {
+        if (result.error)
+            console.error("Error obteniendo categoría por translation key:", result.error);
+        return null;
+    }
+    return result.data;
+}
+export function buildCategoryMetadata({ category, canonical, useYoast = true, siteName, languages, siteUrl, wpApiUrl, }) {
+    const fallbackDescription = getPlainTextExcerpt(category.description, 160);
+    const languageAlternates = withXDefault(languages);
+    const fallbackMetadata = {
+        title: category.name,
+        description: fallbackDescription,
+        alternates: {
+            canonical,
+            ...(languageAlternates ? { languages: languageAlternates } : {}),
+        },
+        openGraph: {
+            title: category.name,
+            description: fallbackDescription,
+            url: canonical,
+            siteName,
+            type: "website",
+        },
+        twitter: {
+            card: "summary_large_image",
+            title: category.name,
+            description: fallbackDescription,
+        },
+    };
+    if (!useYoast)
+        return fallbackMetadata;
+    const meta = extractYoastMetadata(category, {
+        url: canonical,
+        title: category.name,
+        description: fallbackDescription,
+        siteName,
+    }, { siteUrl, wpApiUrl });
+    if (!meta)
+        return fallbackMetadata;
+    return {
+        ...meta,
+        alternates: {
+            ...(meta.alternates || {}),
+            canonical,
+            ...(languageAlternates ? { languages: languageAlternates } : {}),
+        },
+        openGraph: {
+            ...meta.openGraph,
+            url: canonical,
+            siteName: meta.openGraph?.siteName || siteName,
+        },
+    };
+}

package/dist/base/category/pagination.d.ts

@@ -0,0 +1,44 @@
+import { type WPCategory, type WPPost } from "wpjsapi-lib";
+import type { Metadata } from "next";
+type CategoryStaticParamsInput = {
+    baseApiUrl: string;
+    perPage: number;
+    lang: string;
+    langId: string;
+};
+type CategoryStaticParam = {
+    category: string;
+    page: string;
+};
+export declare function getCategoryPaginationStaticParams({ baseApiUrl, perPage, lang, langId, }: CategoryStaticParamsInput): Promise<CategoryStaticParam[]>;
+export declare function fetchCategoryBySlug({ baseApiUrl, slug, lang, }: {
+    baseApiUrl: string;
+    slug: string;
+    lang: string;
+}): Promise<WPCategory | null>;
+export declare function fetchCategoryPaginatedPosts({ baseApiUrl, categoryId, page, perPage, langId, }: {
+    baseApiUrl: string;
+    categoryId: number;
+    page: number;
+    perPage: number;
+    langId: string;
+}): Promise<{
+    posts: WPPost[];
+    totalPages: number;
+    error: string | null;
+}>;
+export declare function getCategoryTotalPages({ baseApiUrl, categoryId, perPage, langId, }: {
+    baseApiUrl: string;
+    categoryId: number;
+    perPage: number;
+    langId: string;
+}): Promise<number>;
+export declare function buildCategoryPaginationMetadata({ category, canonicalBaseUrl, currentPage, useYoast, siteName, languages, }: {
+    category: WPCategory;
+    canonicalBaseUrl: string;
+    currentPage: number;
+    useYoast?: boolean;
+    siteName?: string;
+    languages?: Record<string, string>;
+}): Metadata;
+export {};

package/dist/base/category/pagination.js

@@ -0,0 +1,114 @@
+import { buildCategoryMetadata } from "./index";
+import { createWpClient } from "../../api/wpClient";
+import { getPostsTotalPages, listPostsWithEmbeds } from "../../api/posts";
+import { mapCategoryEntity } from "../../api/mappers";
+import { getCategoryBySlug as getCategoryBySlugApi } from "../../api/categories";
+import { ensureTrailingSlash } from "../../utils";
+export async function getCategoryPaginationStaticParams({ baseApiUrl, perPage, lang, langId, }) {
+    const { categoriesApi } = createWpClient({
+        baseUrl: baseApiUrl,
+    });
+    try {
+        const categories = await categoriesApi.listAll({ lang });
+        const paths = [];
+        for (const category of categories) {
+            const totalPagesResult = await getPostsTotalPages({
+                baseApiUrl,
+                perPage,
+                langId,
+                categories: [category.id],
+            });
+            if (!totalPagesResult.ok && totalPagesResult.error) {
+                console.error("Error obteniendo total de páginas de la categoría:", totalPagesResult.error);
+            }
+            const totalPages = totalPagesResult.ok && totalPagesResult.data
+                ? totalPagesResult.data
+                : 0;
+            for (let page = 2; page <= totalPages; page++) {
+                paths.push({
+                    category: category.slug,
+                    page: String(page),
+                });
+            }
+        }
+        return paths;
+    }
+    catch (error) {
+        console.error("Error generando rutas de paginación de categorías:", error);
+        return [];
+    }
+}
+export async function fetchCategoryBySlug({ baseApiUrl, slug, lang, }) {
+    const result = await getCategoryBySlugApi({
+        baseApiUrl,
+        slug,
+        lang,
+    });
+    if (!result.ok) {
+        if (result.error)
+            console.error("Error obteniendo categoría:", result.error);
+        return null;
+    }
+    return result.data;
+}
+export async function fetchCategoryPaginatedPosts({ baseApiUrl, categoryId, page, perPage, langId, }) {
+    try {
+        const response = await listPostsWithEmbeds({
+            baseApiUrl,
+            categories: [categoryId],
+            perPage,
+            page,
+            orderby: "date",
+            order: "desc",
+            langId,
+        });
+        if (!response.ok || !response.data) {
+            const error = response.error || "Error obteniendo posts de la categoría";
+            console.error(error);
+            return { posts: [], totalPages: 0, error };
+        }
+        return {
+            posts: response.data.items,
+            totalPages: response.data.pagination.totalPages,
+            error: null,
+        };
+    }
+    catch (error) {
+        console.error("Error obteniendo posts de la categoría:", error);
+        return {
+            posts: [],
+            totalPages: 0,
+            error: error instanceof Error ? error.message : "Error desconocido",
+        };
+    }
+}
+export async function getCategoryTotalPages({ baseApiUrl, categoryId, perPage, langId, }) {
+    const result = await getPostsTotalPages({
+        baseApiUrl,
+        perPage,
+        langId,
+        categories: [categoryId],
+    });
+    if (!result.ok || result.data === null) {
+        if (result.error) {
+            console.error("Error obteniendo total de páginas de la categoría:", result.error);
+        }
+        return 0;
+    }
+    return result.data;
+}
+export function buildCategoryPaginationMetadata({ category, canonicalBaseUrl, currentPage, useYoast = true, siteName, languages, }) {
+    const canonical = currentPage === 1
+        ? ensureTrailingSlash(canonicalBaseUrl)
+        : ensureTrailingSlash(`${canonicalBaseUrl.replace(/\/+$/, "")}/page/${currentPage}`);
+    const baseMeta = buildCategoryMetadata({
+        category: mapCategoryEntity(category).category,
+        canonical,
+        useYoast,
+        siteName,
+        languages,
+    });
+    return {
+        ...baseMeta,
+    };
+}

package/dist/base/home/index.d.ts

@@ -0,0 +1,13 @@
+import { type WPPost } from "wpjsapi-lib";
+type FetchHomePostsParams = {
+    baseApiUrl: string;
+    perPage: number;
+    langId: string;
+};
+type FetchHomePostsResult = {
+    posts: WPPost[];
+    totalPages: number;
+    error: string | null;
+};
+export declare function fetchHomePosts({ baseApiUrl, perPage, langId, }: FetchHomePostsParams): Promise<FetchHomePostsResult>;
+export {};

package/dist/base/home/index.js

@@ -0,0 +1,20 @@
+import { listPostsWithEmbeds } from "../../api/posts";
+export async function fetchHomePosts({ baseApiUrl, perPage, langId, }) {
+    const postsResponse = await listPostsWithEmbeds({
+        perPage,
+        baseApiUrl,
+        orderby: "date",
+        order: "desc",
+        langId,
+    });
+    if (!postsResponse.ok || !postsResponse.data) {
+        const error = postsResponse.error || "Error desconocido";
+        console.error("Error obteniendo posts:", error);
+        return { posts: [], totalPages: 0, error };
+    }
+    return {
+        posts: postsResponse.data.items,
+        totalPages: postsResponse.data.pagination.totalPages,
+        error: null,
+    };
+}

package/dist/base/home/pagination.d.ts

@@ -0,0 +1,36 @@
+import { type WPPost } from "wpjsapi-lib";
+import type { Metadata } from "next";
+type StaticParamsInput = {
+    baseApiUrl: string;
+    perPage: number;
+    langId: string;
+};
+export declare function getHomePaginationStaticParams({ baseApiUrl, perPage, langId, }: StaticParamsInput): Promise<Array<{
+    page: string;
+}>>;
+export declare function getHomeTotalPages({ baseApiUrl, perPage, langId, }: {
+    baseApiUrl: string;
+    perPage: number;
+    langId: string;
+}): Promise<number>;
+type FetchPaginatedPostsInput = {
+    baseApiUrl: string;
+    perPage: number;
+    page: number;
+    langId: string;
+};
+type FetchPaginatedPostsResult = {
+    posts: WPPost[];
+    totalPages: number;
+    error: string | null;
+};
+export declare function fetchHomePaginatedPosts({ baseApiUrl, perPage, page, langId, }: FetchPaginatedPostsInput): Promise<FetchPaginatedPostsResult>;
+export declare function buildHomePaginationMetadata({ translator, currentPage, canonicalBase, posts, siteName, languages, }: {
+    translator: (key: string, vars?: Record<string, string | number>) => string;
+    currentPage: number;
+    canonicalBase: string;
+    posts: WPPost[];
+    siteName?: string;
+    languages?: Record<string, string>;
+}): Metadata;
+export {};