@asteroidcms/core-utils 0.1.8 → 0.2.1

package/dist/server.js

@@ -0,0 +1,669 @@
+import 'server-only';
+import * as React from 'react';
+import { Fragment as Fragment$1 } from 'react';
+import { HttpLink, ApolloClient, InMemoryCache, ApolloLink, CombinedGraphQLErrors, CombinedProtocolErrors, gql } from '@apollo/client';
+import { SetContextLink } from '@apollo/client/link/context';
+import { ErrorLink } from '@apollo/client/link/error';
+import { ArticleSearchBox } from '@asteroidcms/core-utils/client';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+// src/server.ts
+function createErrorLink(onError) {
+  return new ErrorLink(({ error }) => {
+    if (!onError) return;
+    if (CombinedGraphQLErrors.is(error)) {
+      error.errors.forEach((e) => onError(e));
+    } else if (CombinedProtocolErrors.is(error)) {
+      error.errors.forEach((e) => onError(e));
+    } else {
+      onError(error);
+    }
+  });
+}
+
+// src/apollo/createApolloClient.ts
+var trimTrailingSlash = (s) => s.replace(/\/+$/, "");
+var ensureLeadingSlash = (s) => s.startsWith("/") ? s : `/${s}`;
+function resolveConfig(config) {
+  if (!config.cmsUrl) throw new Error("AsteroidCMSProvider: `cmsUrl` is required.");
+  if (!config.apiKey) throw new Error("AsteroidCMSProvider: `apiKey` is required.");
+  return {
+    cmsUrl: trimTrailingSlash(config.cmsUrl),
+    apiKey: config.apiKey,
+    graphqlPath: ensureLeadingSlash(config.graphqlPath ?? "/graphql"),
+    mediaPath: ensureLeadingSlash(config.mediaPath ?? "/media/canonical"),
+    headers: config.headers ?? {},
+    onError: config.onError
+  };
+}
+function createApolloClient(config) {
+  if (config.client) return config.client;
+  const resolved = resolveConfig(config);
+  const uri = `${resolved.cmsUrl}${resolved.graphqlPath}`;
+  const authLink = new SetContextLink((_op, prevContext) => {
+    const prevHeaders = prevContext.headers ?? {};
+    return {
+      ...prevContext,
+      headers: {
+        ...prevHeaders,
+        "x-api-key": resolved.apiKey,
+        ...resolved.headers
+      }
+    };
+  });
+  const httpLink = new HttpLink({ uri });
+  return new ApolloClient({
+    link: ApolloLink.from([createErrorLink(resolved.onError), authLink, httpLink]),
+    cache: new InMemoryCache(config.cacheConfig),
+    defaultOptions: {
+      watchQuery: {
+        fetchPolicy: "cache-and-network",
+        errorPolicy: "all",
+        returnPartialData: false
+      },
+      query: { fetchPolicy: "network-only", errorPolicy: "all" },
+      mutate: { errorPolicy: "none" }
+    },
+    ...config.apolloOptions
+  });
+}
+
+// src/server/cmsServerClient.ts
+var reactCache = React.cache ?? ((fn) => fn);
+function createCmsServerClient(config) {
+  const resolved = resolveConfig({
+    cmsUrl: config.cmsUrl,
+    apiKey: config.apiKey,
+    graphqlPath: config.graphqlPath,
+    headers: config.headers
+  });
+  const next = config.revalidate !== void 0 || config.tags !== void 0 ? { revalidate: config.revalidate, tags: config.tags } : void 0;
+  const factory = config.getClient ?? (() => createApolloClient({
+    cmsUrl: resolved.cmsUrl,
+    apiKey: resolved.apiKey,
+    graphqlPath: resolved.graphqlPath,
+    headers: resolved.headers,
+    ...next ? { apolloOptions: { defaultContext: { fetchOptions: { next } } } } : {}
+  }));
+  return { getClient: reactCache(factory), cmsUrl: resolved.cmsUrl };
+}
+function buildSelection(items = []) {
+  const lines = [];
+  items.forEach((item) => {
+    if (typeof item === "string") {
+      lines.push(`${item}: dataField(slug: "${item}")`);
+      return;
+    }
+    if ("field" in item && typeof item.field === "string") {
+      if (!("select" in item)) {
+        const alias2 = item.as || item.field;
+        lines.push(`${alias2}: dataField(slug: "${item.field}")`);
+        return;
+      }
+      const alias = item.as || item.field;
+      const resolver = item.single ? "expandedReferenceObject" : "expandedReference";
+      const subSelection = item.select?.length ? buildSelection(item.select) : "data { ... }";
+      lines.push(`
+        ${alias}: ${resolver}(slug: "${item.field}") {
+          ${subSelection}
+        }
+      `);
+    }
+  });
+  return lines.join("\n      ").trim();
+}
+function buildCmsQuery({
+  schema_slug,
+  entrySlug,
+  select = [],
+  fullData = false,
+  limit,
+  offset,
+  status = "PUBLISHED",
+  filter,
+  search,
+  variables = {}
+}) {
+  const isSingle = Boolean(entrySlug);
+  const selectionParts = [];
+  if (fullData) {
+    selectionParts.push("data");
+  }
+  if (select.length > 0) {
+    const userSelection = buildSelection(select);
+    if (userSelection) {
+      selectionParts.push(userSelection);
+    }
+  }
+  const selection = selectionParts.join("\n      ").trim() || "id";
+  const queryVariables = {
+    schema_slug,
+    ...entrySlug && { slug: entrySlug },
+    ...variables
+  };
+  const fieldArgParts = ["schema_slug: $schema_slug"];
+  if (!isSingle) {
+    if (typeof limit === "number" && limit >= 0) {
+      fieldArgParts.push("limit: $limit");
+      queryVariables.limit = limit;
+    }
+    if (typeof offset === "number" && offset >= 0) {
+      fieldArgParts.push("offset: $offset");
+      queryVariables.offset = offset;
+    }
+    if (status) {
+      const statuses = status;
+      if (statuses.length > 0) {
+        fieldArgParts.push("status: $status");
+        queryVariables.status = statuses;
+      }
+    }
+    const hasSearch = Array.isArray(search) && search.length > 0;
+    const hasFilter = filter && typeof filter === "object" && Object.keys(filter).length > 0;
+    if (hasSearch || hasFilter) {
+      const mergedFilter = hasFilter ? { ...filter } : {};
+      if (hasSearch) {
+        for (const condition of search) {
+          mergedFilter[condition.field] = {
+            regex: true,
+            value: condition.value,
+            mode: condition.mode ?? "i"
+          };
+        }
+      }
+      fieldArgParts.push("data: $filter");
+      queryVariables.filter = mergedFilter;
+    }
+  }
+  const varDecls = ["$schema_slug: String!"];
+  if ("limit" in queryVariables) varDecls.push("$limit: Float");
+  if ("offset" in queryVariables) varDecls.push("$offset: Float");
+  if ("status" in queryVariables) varDecls.push("$status: ContentStatus");
+  if ("filter" in queryVariables) varDecls.push("$filter: JSONObject");
+  const varBlock = varDecls.length > 0 ? `(
+  ${varDecls.join("\n  ")}
+)` : "";
+  const contentFieldArgs = fieldArgParts.join(", ");
+  const queryStr = isSingle ? `
+      query Get${schema_slug}Entry($schema_slug: String!, $slug: String!) {
+        entry: contentEntry(schema_slug: $schema_slug, slug: $slug) {
+          ${selection}
+        }
+      }
+    ` : `
+      query Get${schema_slug}Entries${varBlock} {
+        entries: contentEntries(${contentFieldArgs}) {
+          ${selection}
+        }
+      }
+    `;
+  return {
+    query: gql(queryStr),
+    variables: queryVariables,
+    isSingle
+  };
+}
+
+// src/fetchCmsContent.ts
+async function fetchCmsContent(getClient, opts) {
+  const { query, variables, isSingle } = buildCmsQuery(opts);
+  const { data } = await getClient().query({ query, variables });
+  return isSingle ? data.entry : data.entries;
+}
+
+// src/server/defineArticleSource.ts
+function buildSearchConditions(fields, query) {
+  const trimmed = query?.trim();
+  if (!trimmed) return void 0;
+  return fields.map((field) => ({ field, value: trimmed, mode: "i" }));
+}
+function defineArticleSource(config) {
+  return Object.freeze({
+    client: config.client,
+    schemaSlug: config.schemaSlug,
+    listSelect: config.listSelect,
+    detailSelect: config.detailSelect,
+    seo: config.seo.cmsUrl ? config.seo : { ...config.seo, cmsUrl: config.client.cmsUrl },
+    searchFields: config.searchFields ?? ["title", "description"],
+    status: config.status ?? "PUBLISHED",
+    articleType: config.articleType ?? "Article",
+    relatedLimit: config.relatedLimit ?? 3,
+    groupPostsByCategory: config.groupPostsByCategory
+  });
+}
+async function fetchArticles(source, opts = {}) {
+  const search = buildSearchConditions(source.searchFields, opts.searchQuery);
+  const data = await fetchCmsContent(source.client.getClient, {
+    schema_slug: source.schemaSlug,
+    select: source.listSelect,
+    status: source.status,
+    ...opts.limit !== void 0 ? { limit: opts.limit } : {},
+    ...opts.categorySlug ? { filter: { category: opts.categorySlug } } : {},
+    ...search ? { search } : {}
+  });
+  return Array.isArray(data) ? data : [];
+}
+async function fetchArticle(source, slug) {
+  try {
+    const data = await fetchCmsContent(source.client.getClient, {
+      schema_slug: source.schemaSlug,
+      entrySlug: slug,
+      select: source.detailSelect,
+      status: source.status
+    });
+    return data ?? null;
+  } catch {
+    return null;
+  }
+}
+async function fetchRelatedArticles(source, post, slug) {
+  const categorySlug = post.category?.slug?.trim();
+  if (!categorySlug || source.relatedLimit <= 0) return [];
+  const data = await fetchCmsContent(source.client.getClient, {
+    schema_slug: source.schemaSlug,
+    select: source.listSelect,
+    status: source.status,
+    limit: source.relatedLimit + 1,
+    filter: { category: categorySlug }
+  });
+  return (Array.isArray(data) ? data : []).filter((p) => p.slug !== slug).slice(0, source.relatedLimit);
+}
+
+// src/seo/jsonld.ts
+function buildArticleJsonLd(props) {
+  return {
+    "@context": "https://schema.org",
+    "@type": props.articleType ?? "Article",
+    headline: props.title,
+    description: props.description,
+    url: props.url,
+    ...props.image ? { image: props.image } : {},
+    ...props.publishedTime ? { datePublished: props.publishedTime } : {},
+    ...props.category ? { articleSection: props.category } : {},
+    ...props.tags && props.tags.length > 0 ? { keywords: props.tags.join(", ") } : {},
+    author: { "@type": "Person", name: props.authorName || props.siteName },
+    publisher: { "@id": `${props.siteUrl}/#organization` },
+    isPartOf: { "@id": `${props.siteUrl}/#website` },
+    inLanguage: "en-US"
+  };
+}
+function buildCollectionJsonLd(props) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "CollectionPage",
+    name: props.name,
+    description: props.description,
+    url: props.url,
+    isPartOf: { "@id": `${props.siteUrl}/#website` },
+    publisher: { "@id": `${props.siteUrl}/#organization` },
+    inLanguage: "en-US"
+  };
+}
+
+// src/utils/cmsImage.ts
+function cmsImage(id, options) {
+  if (!id) return "";
+  const base = options.cmsUrl.replace(/\/+$/, "");
+  const path = (options.mediaPath ?? "/media/canonical").replace(/^\/?/, "/");
+  return `${base}${path}/${id}`;
+}
+function createImageResolver(options) {
+  return (idOrUrl) => {
+    if (!idOrUrl) return "";
+    if (/^https?:\/\//i.test(idOrUrl)) return idOrUrl;
+    if (!options.cmsUrl) return "";
+    return cmsImage(idOrUrl, { cmsUrl: options.cmsUrl, mediaPath: options.mediaPath });
+  };
+}
+
+// src/components/articles/articles.state.ts
+function defaultGetCategoryName(post) {
+  return post.category?.name?.trim() || void 0;
+}
+function defaultGroupPostsByCategory(posts) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const post of posts) {
+    const categoryName = defaultGetCategoryName(post) || "Other";
+    const categorySlug = post.category?.slug || "other";
+    const existing = groups.get(categorySlug);
+    if (existing) {
+      existing.posts.push(post);
+    } else {
+      groups.set(categorySlug, { categoryName, categorySlug, posts: [post] });
+    }
+  }
+  return Array.from(groups.values());
+}
+function applyPostFilters(posts, { categorySlug, articleSlug }) {
+  let filtered = posts;
+  if (categorySlug) {
+    filtered = filtered.filter((post) => post.category?.slug === categorySlug);
+  }
+  if (articleSlug) {
+    filtered = filtered.filter((post) => post.slug === articleSlug);
+  }
+  return filtered;
+}
+function splitFeaturedAndRest(posts) {
+  const featured = posts.find((post) => post.featured) ?? null;
+  const rest = featured ? posts.filter((post) => post.slug !== featured.slug) : [...posts];
+  return { featured, rest };
+}
+function buildArticlesViewState(rawPosts, options) {
+  const {
+    categorySlug,
+    articleSlug,
+    searchQuery = "",
+    groupPostsByCategory = defaultGroupPostsByCategory
+  } = options;
+  const posts = applyPostFilters(rawPosts, { categorySlug, articleSlug });
+  const { featured, rest } = splitFeaturedAndRest(posts);
+  const trimmedQuery = searchQuery.trim();
+  const isSearching = trimmedQuery.length > 0;
+  const categoryGroups = isSearching ? posts.length === 0 ? [] : [
+    {
+      categoryName: `Search results for "${trimmedQuery}"`,
+      categorySlug: "search-results",
+      posts
+    }
+  ] : groupPostsByCategory(rest);
+  return {
+    posts,
+    featured,
+    rest,
+    categoryGroups,
+    isEmpty: !featured && rest.length === 0,
+    isSearching,
+    searchQuery: trimmedQuery
+  };
+}
+function renderArticlesListingBody(args) {
+  const { state, hasError, error, cmsImage: cmsImage2, searchNode, seoNode, jsonLdNode, renderProps } = args;
+  const {
+    eyebrow,
+    title,
+    description,
+    renderRoot,
+    renderHeader,
+    renderFeaturedCard,
+    renderPostCard,
+    renderCategoryHeading,
+    renderPostGrid,
+    renderCategoryGroup,
+    renderSkeleton,
+    renderEmpty,
+    renderContent
+  } = renderProps;
+  const headerNode = renderHeader ? renderHeader({ eyebrow, title, description, search: searchNode }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+    eyebrow,
+    title,
+    description,
+    searchNode
+  ] });
+  const featuredNode = state.featured && !state.isSearching && renderFeaturedCard ? renderFeaturedCard({ post: state.featured, cmsImage: cmsImage2 }) : null;
+  const noSearchResultsNode = state.isSearching && true && state.posts.length === 0 ? renderEmpty?.({ reason: "no-results", searchQuery: state.searchQuery }) ?? null : null;
+  const groupsNode = noSearchResultsNode ? null : state.categoryGroups.map((group) => {
+    const postCards = group.posts.map((post, index) => /* @__PURE__ */ jsx(Fragment$1, { children: renderPostCard({ post, index, group, cmsImage: cmsImage2 }) }, post.slug ?? index));
+    const gridNode = renderPostGrid ? renderPostGrid({ posts: group.posts, group, children: postCards }) : /* @__PURE__ */ jsx(Fragment, { children: postCards });
+    const headingNode = renderCategoryHeading ? renderCategoryHeading({ group }) : group.categoryName;
+    const defaultContent = /* @__PURE__ */ jsxs(Fragment, { children: [
+      headingNode,
+      gridNode
+    ] });
+    return /* @__PURE__ */ jsx(Fragment$1, { children: renderCategoryGroup ? renderCategoryGroup({ group, defaultContent }) : defaultContent }, group.categorySlug);
+  });
+  const contentNode = !hasError && (state.featured || state.rest.length > 0) ? renderContent ? renderContent({ featured: featuredNode, groups: groupsNode, noSearchResults: noSearchResultsNode }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+    featuredNode,
+    noSearchResultsNode,
+    groupsNode
+  ] }) : null;
+  const body = /* @__PURE__ */ jsxs(Fragment, { children: [
+    seoNode,
+    jsonLdNode,
+    headerNode,
+    null,
+    (hasError || state.isEmpty) ? renderEmpty?.({
+      reason: hasError ? "error" : state.isSearching ? "no-results" : "no-posts",
+      searchQuery: state.searchQuery,
+      error
+    }) : null,
+    contentNode
+  ] });
+  return renderRoot ? renderRoot({ children: body }) : /* @__PURE__ */ jsx(Fragment, { children: body });
+}
+async function AsteroidArticlesListingServer(props) {
+  const {
+    source,
+    searchQuery = "",
+    categorySlug,
+    articleSlug,
+    searchParamKey = "q",
+    limit,
+    noindex,
+    searchBoxProps,
+    renderSearch,
+    renderJsonLd,
+    groupPostsByCategory,
+    ...renderProps
+  } = props;
+  let rawPosts = [];
+  let hasError = false;
+  let error = void 0;
+  try {
+    rawPosts = await fetchArticles(source, { searchQuery, categorySlug, limit });
+  } catch (err) {
+    hasError = true;
+    error = err;
+  }
+  const state = buildArticlesViewState(rawPosts, {
+    categorySlug,
+    articleSlug,
+    searchQuery,
+    groupPostsByCategory
+  });
+  const cmsImage2 = createImageResolver({ cmsUrl: source.seo.cmsUrl ?? source.client.cmsUrl });
+  const categoryName = categorySlug ? state.posts[0]?.category?.name?.trim() : void 0;
+  const collection = buildCollectionJsonLd({
+    name: categoryName || `${source.seo.siteName} ${source.seo.contentLabel ?? "Articles"}`,
+    description: source.seo.defaultDescription || "",
+    url: `${(source.seo.baseUrl || "").replace(/\/$/, "")}${source.seo.articlePath ?? "/blog"}${categorySlug ? `/category/${categorySlug}` : ""}`,
+    siteUrl: (source.seo.baseUrl || "").replace(/\/$/, "")
+  });
+  const jsonLdNode = renderJsonLd?.(state) ?? /* @__PURE__ */ jsx("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: JSON.stringify(collection) } });
+  const searchNode = renderSearch ? renderSearch({ value: searchQuery, onChange: () => {
+  }, onSubmit: (e) => e.preventDefault() }) : /* @__PURE__ */ jsx(ArticleSearchBox, { paramKey: searchParamKey, ...searchBoxProps });
+  return /* @__PURE__ */ jsx(Fragment, { children: renderArticlesListingBody({
+    state,
+    hasError,
+    error,
+    cmsImage: cmsImage2,
+    searchNode,
+    seoNode: null,
+    jsonLdNode,
+    renderProps
+  }) });
+}
+
+// src/seo/seo.builders.ts
+function applyTitleTemplate(config, title) {
+  return config.titleTemplate ? config.titleTemplate(title) : `${title} | ${config.siteName}`;
+}
+function buildOgImageUrl(config, params) {
+  if (config.getOgImageUrl) {
+    return config.getOgImageUrl(params);
+  }
+  const palette = config.ogImage?.palette;
+  if (!palette) return void 0;
+  const apiPath = config.ogImage?.apiPath ?? "/api/og";
+  const base = config.baseUrl.replace(/\/$/, "");
+  const searchParams = new URLSearchParams({
+    title: params.title,
+    type: params.type ?? "article",
+    siteName: config.siteName,
+    bg: palette.background,
+    fg: palette.foreground,
+    accent: palette.accent
+  });
+  if (params.subtitle?.trim()) searchParams.set("subtitle", params.subtitle.trim());
+  if (params.eyebrow?.trim()) searchParams.set("eyebrow", params.eyebrow.trim());
+  if (palette.accentMuted) searchParams.set("accentMuted", palette.accentMuted);
+  if (palette.mutedText) searchParams.set("muted", palette.mutedText);
+  return `${base}${apiPath}?${searchParams.toString()}`;
+}
+function resolveArticleImage(post, config) {
+  const featuredImage = config.cmsUrl ? cmsImage(post.featured_image, { cmsUrl: config.cmsUrl }) : "";
+  if (featuredImage) return featuredImage;
+  const description = post.meta_description?.trim() || post.description?.trim() || config.defaultDescription;
+  return buildOgImageUrl(config, {
+    title: post.title,
+    subtitle: description,
+    eyebrow: config.contentLabel ?? "Article",
+    type: "article"
+  });
+}
+function buildArticleSeoValues(post, config, slug, options) {
+  const articlePath = config.articlePath ?? "/blog";
+  const url = `${config.baseUrl.replace(/\/$/, "")}${articlePath}/${slug}`;
+  const description = post.meta_description?.trim() || post.description?.trim() || config.defaultDescription || `Read the latest from ${config.siteName}.`;
+  return {
+    title: applyTitleTemplate(config, post.title),
+    siteName: config.siteName,
+    twitter: config.twitter ?? "",
+    description,
+    url,
+    keywords: config.defaultKeywords ?? post.title,
+    image: resolveArticleImage(post, config),
+    noindex: options?.noindex ?? config.noindex,
+    manifestUrl: config.manifestUrl
+  };
+}
+function buildArticleListingSeoValues(config, options) {
+  const articlePath = config.articlePath ?? "/blog";
+  const base = config.baseUrl.replace(/\/$/, "");
+  const label = config.contentLabel ?? "Articles";
+  const categoryName = options?.categoryName?.trim();
+  const categorySlug = options?.categorySlug?.trim();
+  const titleText = categoryName ? `${categoryName} ${label}` : label;
+  const description = categoryName ? `Explore ${categoryName} ${label.toLowerCase()}, guides, and the latest updates from ${config.siteName}.` : config.defaultDescription || `Browse ${label.toLowerCase()}, insights, and the latest updates from ${config.siteName}.`;
+  const url = categorySlug ? `${base}${articlePath}/category/${categorySlug}` : `${base}${articlePath}`;
+  return {
+    title: applyTitleTemplate(config, titleText),
+    siteName: config.siteName,
+    twitter: config.twitter ?? "",
+    description,
+    url,
+    keywords: config.defaultKeywords ?? (categoryName ? `${categoryName}, ${config.siteName}` : `${config.siteName} ${label.toLowerCase()}`),
+    image: buildOgImageUrl(config, {
+      title: titleText,
+      subtitle: description,
+      eyebrow: categoryName ? "Category" : label,
+      type: "listing"
+    }),
+    noindex: options?.noindex ?? config.noindex,
+    manifestUrl: config.manifestUrl
+  };
+}
+function renderArticleBody(args) {
+  const { post, cmsImage: cmsImage2, relatedPosts, seoNode, jsonLdNode, renderProps: r } = args;
+  const slot = { post, cmsImage: cmsImage2 };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    seoNode,
+    jsonLdNode,
+    r.backLink,
+    r.renderPreArticle?.(slot),
+    r.renderHeader?.(slot),
+    r.renderMeta?.(slot),
+    r.renderDescription?.(slot),
+    r.renderFeaturedImage?.(slot),
+    r.renderToc?.(slot),
+    r.renderContent?.(slot),
+    r.renderMidArticle?.(slot),
+    r.renderTags?.(slot),
+    r.renderAuthorDetails?.(slot),
+    r.renderRelatedPosts?.({ post, relatedPosts, cmsImage: cmsImage2 }),
+    r.renderCTA?.(slot),
+    r.renderPostArticle?.(slot)
+  ] });
+}
+async function AsteroidArticlePageServer(props) {
+  const { source, slug, articleType, noindex, renderError, renderJsonLd, ...bodyRenderProps } = props;
+  const article = await fetchArticle(source, slug);
+  if (!article) {
+    return /* @__PURE__ */ jsx(Fragment, { children: renderError?.({ reason: "not-found" }) ?? null });
+  }
+  const relatedPosts = await fetchRelatedArticles(source, article, slug);
+  const cmsImage2 = createImageResolver({ cmsUrl: source.seo.cmsUrl ?? source.client.cmsUrl });
+  const type = articleType ?? source.articleType;
+  const seoValues = buildArticleSeoValues(article, source.seo, slug, { noindex });
+  const articleLd = buildArticleJsonLd({
+    title: article.title,
+    description: article.description || source.seo.defaultDescription || "",
+    url: `${(source.seo.baseUrl || "").replace(/\/$/, "")}${source.seo.articlePath ?? "/blog"}/${slug}`,
+    siteName: source.seo.siteName,
+    siteUrl: (source.seo.baseUrl || "").replace(/\/$/, ""),
+    articleType: type,
+    image: seoValues.image,
+    authorName: article.author?.name,
+    publishedTime: article.published_date || void 0,
+    tags: article.tags?.split(",").map((t) => t.trim()).filter(Boolean),
+    category: article.category?.name
+  });
+  const jsonLdNode = renderJsonLd?.({ post: article }) ?? /* @__PURE__ */ jsx("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: JSON.stringify(articleLd) } });
+  return /* @__PURE__ */ jsx(Fragment, { children: renderArticleBody({
+    post: article,
+    cmsImage: cmsImage2,
+    relatedPosts,
+    seoNode: null,
+    jsonLdNode,
+    renderProps: bodyRenderProps
+  }) });
+}
+
+// src/server/articleMetadata.ts
+function seoValuesToMetadata(v, ogType) {
+  return {
+    title: v.title,
+    description: v.description,
+    publisher: v.siteName,
+    keywords: v.keywords,
+    category: v.title,
+    ...v.manifestUrl ? { manifest: v.manifestUrl } : {},
+    robots: v.noindex ? { index: false, follow: true } : { index: true, follow: true },
+    authors: { name: v.siteName },
+    referrer: "origin",
+    abstract: v.description,
+    alternates: { canonical: v.url },
+    openGraph: {
+      title: v.title,
+      description: v.description,
+      url: v.url,
+      siteName: v.siteName,
+      locale: "en_US",
+      type: ogType,
+      ...v.image ? { images: [{ url: v.image }] } : {}
+    },
+    twitter: {
+      title: v.title,
+      description: v.description,
+      site: v.twitter || void 0,
+      card: v.image ? "summary_large_image" : "summary",
+      ...v.image ? { images: [v.image] } : {}
+    }
+  };
+}
+async function generateListingMetadata(source, options) {
+  return seoValuesToMetadata(buildArticleListingSeoValues(source.seo, options), "website");
+}
+async function generateArticleMetadata(source, paramsOrSlug) {
+  const resolved = await paramsOrSlug;
+  const slug = typeof resolved === "string" ? resolved : resolved.slug;
+  const article = await fetchArticle(source, slug);
+  if (!article) {
+    return seoValuesToMetadata(buildArticleListingSeoValues(source.seo), "website");
+  }
+  return seoValuesToMetadata(buildArticleSeoValues(article, source.seo, slug), "article");
+}
+
+export { AsteroidArticlePageServer, AsteroidArticlesListingServer, buildSearchConditions, createCmsServerClient, defineArticleSource, fetchArticle, fetchArticles, fetchRelatedArticles, generateArticleMetadata, generateListingMetadata };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map