@justanarthur/payload-www 0.1.1

package/dist/metadata.js

@@ -0,0 +1,335 @@
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/render/metadata/jsonld.ts
+function getImageUrl(doc, siteUrl) {
+  const img = doc?.meta?.image ?? doc?.heroImage ?? doc?.image;
+  if (!img)
+    return null;
+  if (typeof img === "string")
+    return img;
+  if (img?.url)
+    return img.url.startsWith("http") ? img.url : `${siteUrl}${img.url}`;
+  return null;
+}
+function resolveLocalizedField(value, locale) {
+  if (value == null)
+    return "";
+  if (typeof value === "string") {
+    if (!value.startsWith("{"))
+      return value;
+    try {
+      const parsed = JSON.parse(value);
+      return resolveLocalizedField(parsed, locale);
+    } catch {
+      return value;
+    }
+  }
+  if (typeof value !== "object")
+    return "";
+  const obj = value;
+  if (typeof obj[locale] === "string" && obj[locale].length > 0) {
+    return obj[locale];
+  }
+  return Object.values(obj).filter((v) => typeof v === "string" && v.length > 0).join(" / ");
+}
+function buildArticleLd({
+  doc,
+  url,
+  locale,
+  siteUrl,
+  type = "BlogPosting",
+  publisherName,
+  publisherLogo
+}) {
+  const name = publisherName ?? new URL(siteUrl).hostname;
+  const ld = {
+    "@context": "https://schema.org",
+    "@type": type,
+    "@id": `${url}#article`,
+    headline: resolveLocalizedField(doc.title, locale),
+    description: resolveLocalizedField(doc.meta?.description ?? doc.description ?? doc.excerpt, locale),
+    inLanguage: locale,
+    url,
+    dateModified: doc.updatedAt ? new Date(doc.updatedAt).toISOString() : undefined
+  };
+  const datePublished = doc.publishedAt ?? doc.createdAt;
+  if (datePublished)
+    ld.datePublished = new Date(datePublished).toISOString();
+  const imgUrl = getImageUrl(doc, siteUrl);
+  if (imgUrl)
+    ld.image = imgUrl;
+  ld.author = { "@type": "Organization", name, url: siteUrl };
+  const publisher = { "@type": "Organization", name };
+  if (publisherLogo !== undefined) {
+    if (publisherLogo !== null)
+      publisher.logo = { "@type": "ImageObject", url: publisherLogo };
+  }
+  ld.publisher = publisher;
+  return ld;
+}
+function buildBreadcrumbsLd({
+  items,
+  currentUrl
+}) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items.map((item, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.label,
+      item: index === items.length - 1 ? currentUrl : item.url
+    }))
+  };
+}
+function buildOrganizationLd({
+  siteUrl,
+  name,
+  logo,
+  sameAs
+}) {
+  const org = {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    "@id": `${siteUrl}#organization`,
+    url: siteUrl,
+    ...name && { name },
+    ...logo && { logo: { "@type": "ImageObject", url: logo } },
+    ...sameAs && sameAs.length > 0 && { sameAs }
+  };
+  return org;
+}
+
+// src/render/metadata/hreflang.ts
+async function buildHreflangAlternates({
+  siteUrl,
+  locale,
+  urlPrefix,
+  storedSlug,
+  queryAllLocaleSlugs,
+  nested,
+  homeSlug,
+  defaultLocale,
+  locales,
+  localePrefix = "always"
+}) {
+  const allLocaleSlugs = await queryAllLocaleSlugs(storedSlug, locale);
+  const languages = {};
+  const urlFor = (l, slug) => {
+    const trimmedPrefix = urlPrefix.replace(/^\/|\/$/g, "");
+    const prefixSegment = trimmedPrefix ? `/${trimmedPrefix}` : "";
+    const urlPath = slug === homeSlug ? "/" : nested ? "/" + slug.replaceAll("_", "/") : "/" + slug;
+    const localeSegment = localePrefix === "never" ? "" : localePrefix === "as-needed" && l === defaultLocale ? "" : `/${l}`;
+    return `${siteUrl}${localeSegment}${prefixSegment}${urlPath}`;
+  };
+  for (const l of locales) {
+    const slugForLocale = allLocaleSlugs?.[l];
+    if (!slugForLocale)
+      continue;
+    languages[l] = urlFor(l, slugForLocale);
+  }
+  if (allLocaleSlugs?.[defaultLocale]) {
+    languages["x-default"] = urlFor(defaultLocale, allLocaleSlugs[defaultLocale]);
+  }
+  return languages;
+}
+
+// src/render/metadata/slug.ts
+var SLUG_NESTED_DIVIDER = "_";
+function segmentsToStoredSlug(segments, nested) {
+  if (!Array.isArray(segments))
+    return segments;
+  if (nested)
+    return segments.join(SLUG_NESTED_DIVIDER);
+  return segments[0] ?? "";
+}
+function segmentsToUrlPath(segments, nested) {
+  if (!Array.isArray(segments))
+    return "/" + segments;
+  if (nested)
+    return "/" + segments.join("/");
+  return "/" + (segments[0] ?? "");
+}
+function storedSlugToSegments(storedSlug, nested) {
+  if (nested)
+    return storedSlug.split(SLUG_NESTED_DIVIDER);
+  return storedSlug;
+}
+function buildCanonicalUrl({
+  siteUrl,
+  locale,
+  urlPrefix,
+  urlPath
+}) {
+  const trimmedPrefix = urlPrefix.replace(/^\/|\/$/g, "");
+  const prefixSegment = trimmedPrefix ? `/${trimmedPrefix}` : "";
+  return `${siteUrl}/${locale}${prefixSegment}${urlPath}`;
+}
+function getUrlPath(segments, nested, homeSlug) {
+  const urlPath = segmentsToUrlPath(segments, nested);
+  if (nested && !Array.isArray(segments)) {
+    if (segments === homeSlug)
+      return "/";
+  } else if (nested && Array.isArray(segments)) {
+    const stored = segments.join(SLUG_NESTED_DIVIDER);
+    if (stored === homeSlug)
+      return "/";
+  }
+  return urlPath;
+}
+
+// src/render/metadata/query.ts
+import { getPayload } from "payload";
+import { cache } from "react";
+
+// src/core/utils/getFromImportMap.ts
+function getFromImportMap(key, importMap) {
+  return importMap[key.includes("#") ? key : key + "#default"];
+}
+
+// src/render/metadata/query.ts
+var queryDocBySlug = cache(async function queryDocBySlug2({
+  collectionSlug,
+  slug,
+  slugField = "slug",
+  locale,
+  draft = false,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft,
+    limit: 1,
+    pagination: false,
+    overrideAccess: draft,
+    where: { [slugField]: { equals: slug } },
+    locale
+  });
+  return result.docs?.[0] ?? null;
+});
+var queryAllDocs = cache(async function queryAllDocs2({
+  collectionSlug,
+  slugField = "slug",
+  locale,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft: false,
+    limit: 1000,
+    pagination: false,
+    overrideAccess: false,
+    select: { [slugField]: true },
+    locale
+  });
+  return result.docs ?? [];
+});
+var queryAllLocaleSlugs = cache(async function queryAllLocaleSlugs2({
+  collectionSlug,
+  slug,
+  slugField = "slug",
+  locale,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft: false,
+    limit: 1,
+    pagination: false,
+    overrideAccess: false,
+    locale,
+    where: { [slugField]: { equals: slug } },
+    select: { [slugField]: true }
+  });
+  const doc = result.docs?.[0];
+  if (!doc)
+    return;
+  const fieldValue = doc?.[slugField];
+  if (fieldValue && typeof fieldValue === "object") {
+    return fieldValue;
+  }
+  const resolved = await config;
+  const rawLocales = Array.isArray(resolved?.localization?.localeCodes) ? resolved.localization.localeCodes : resolved?.localization?.locales?.map((l) => l.code) ?? [];
+  const out = {};
+  for (const l of rawLocales)
+    out[l] = String(fieldValue ?? slug);
+  return out;
+});
+var queryGlobal = cache(async function queryGlobal2({
+  globalSlug,
+  locale,
+  depth = 0,
+  draft = false,
+  config
+}) {
+  const payload = await getPayload({ config });
+  try {
+    const global = await payload.findGlobal({
+      slug: globalSlug,
+      depth,
+      draft,
+      locale
+    });
+    return global;
+  } catch {
+    return null;
+  }
+});
+function getRenderModuleExports(exportName, collection, importMap) {
+  const path = collection?.custom?.path;
+  if (!path)
+    return;
+  const mod = getFromImportMap(path, importMap);
+  return mod?.[exportName];
+}
+
+// src/exports/metadata.ts
+var metadata_default = {
+  buildArticleLd,
+  buildBreadcrumbsLd,
+  buildOrganizationLd,
+  buildHreflangAlternates,
+  queryDocBySlug,
+  queryAllDocs,
+  queryAllLocaleSlugs,
+  getUrlPath,
+  segmentsToStoredSlug,
+  segmentsToUrlPath,
+  storedSlugToSegments,
+  buildCanonicalUrl,
+  getRenderModuleExports
+};
+export {
+  storedSlugToSegments,
+  segmentsToUrlPath,
+  segmentsToStoredSlug,
+  queryDocBySlug,
+  queryAllLocaleSlugs,
+  queryAllDocs,
+  getUrlPath,
+  getRenderModuleExports,
+  metadata_default as default,
+  buildOrganizationLd,
+  buildHreflangAlternates,
+  buildCanonicalUrl,
+  buildBreadcrumbsLd,
+  buildArticleLd
+};

package/dist/pages.d.ts

@@ -0,0 +1,323 @@
+import { ReactElement } from "react";
+import { SanitizedConfig } from "payload";
+type PagesPageProps = {
+	/**
+	* The resolved page document. The host's `[slug]/page.tsx` route
+	* handler is responsible for fetching the doc (via Payload's
+	* `getPayload` or via the lib's `createCollectionPageExports`'s
+	* `generateMetadata` helper). This component just renders the
+	* visual body.
+	*/
+	doc: Record<string, any> | null;
+	/**
+	* Resolved locale string (already validated upstream by the host's
+	* `[locale]` route segment).
+	*/
+	locale: string;
+	/**
+	* Block components keyed by `blockType`. The host passes the same
+	* `importMap` it uses everywhere else; the lib's `RenderBlocks`
+	* resolves each block against the map.
+	*/
+	importMap: Record<string, unknown>;
+	config: SanitizedConfig;
+};
+/**
+* Default visual body for the Pages collection. Renders the doc's
+* `blocks` field via the lib's `RenderBlocks`. Hosts can replace
+* this by setting a different `custom.path` on their own Pages
+* collection (via the lib's `createPagesCollection` factory) and
+* pointing it at their own Server Component.
+*/
+declare function PagesPage({ doc,...props }: PagesPageProps): Promise<ReactElement>;
+import { ReactElement as ReactElement2 } from "react";
+type HeaderPageProps = {
+	/** The resolved Header global document. `null` if the host hasn't
+	* created a Header yet. */
+	data: Record<string, any> | null;
+	/**
+	* Resolved locale string. The default header visual uses this for
+	* per-locale labels via next-intl (if the host has it wired). The
+	* default ships without a label dictionary — the host can override
+	* by setting a different `custom.path` on the header global.
+	*/
+	locale: string;
+};
+/**
+* Default visual for the `header` global. Renders the header's
+* `nav` blocks (a flat list of `navItem` and `navColumn` blocks) as
+* a simple `<nav>` element.
+*
+* Hosts can replace this visual by setting a different `custom.path`
+* on their own header global (via the lib's `createHeaderGlobal`
+* factory).
+*/
+declare function HeaderPage({ data, locale: _locale }: HeaderPageProps): ReactElement2;
+import { ReactElement as ReactElement3 } from "react";
+type FooterPageProps = {
+	/** The resolved Footer global document. `null` if the host hasn't
+	* created a Footer yet. */
+	data: Record<string, any> | null;
+	locale: string;
+};
+/**
+* Default visual for the `footer` global. Renders the footer's
+* `nav` blocks (a flat list of `navItem` and `navColumn` blocks)
+* as a simple `<footer>` element.
+*
+* Hosts can replace this visual by setting a different `custom.path`
+* on their own footer global (via the lib's `createFooterGlobal`
+* factory).
+*/
+declare function FooterPage({ data, locale: _locale }: FooterPageProps): ReactElement3;
+import { Metadata, MetadataRoute } from "next";
+import { DataFromCollectionSlug, ImportMap, SanitizedConfig as SanitizedConfig2 } from "payload";
+import { ReactElement as ReactElement4, ReactNode } from "react";
+type BreadcrumbItem = {
+	label: string;
+	url: string;
+};
+type PageExtendProps = {
+	importMap: ImportMap;
+	config: SanitizedConfig2;
+	locale: string;
+};
+type ArticleJsonLdEntry = {
+	type: "article";
+	id?: string;
+	schemaType?: "BlogPosting" | "Article" | "NewsArticle" | "TechArticle";
+	publisherName?: string;
+	publisherLogo?: string | null;
+};
+type WebSiteJsonLdEntry = {
+	type: "website";
+	id?: string;
+	name?: string;
+	alternateName?: string;
+};
+type OrganizationJsonLdEntry = {
+	type: "organization";
+	id?: string;
+	name?: string;
+	logo?: string;
+	sameAs?: string[];
+};
+type BreadcrumbsJsonLdEntry = {
+	type: "breadcrumbs";
+	id?: string;
+	items?: BreadcrumbItem[];
+	buildItems?: (doc: DataFromCollectionSlug<string>, url: string) => BreadcrumbItem[];
+};
+type CustomJsonLdEntry = {
+	type: "custom";
+	id?: string;
+	build: (ctx: {
+		doc: DataFromCollectionSlug<string>;
+		url: string;
+		locale: string;
+		siteUrl: string;
+	}) => Record<string, unknown>;
+};
+type JsonLdEntry = ArticleJsonLdEntry | WebSiteJsonLdEntry | OrganizationJsonLdEntry | BreadcrumbsJsonLdEntry | CustomJsonLdEntry;
+type JsonLdOutput = {
+	id: string;
+	schema: Record<string, unknown>;
+};
+/**
+* Minimal next-intl routing contract the lib reads. Hosts pass
+* their `defineRouting({...})` result directly; the lib only needs
+* the shape below.
+*
+* `localePrefix` accepts either the simple string form
+* (`'always' | 'as-needed' | 'never'`) or next-intl's verbose
+* `LocalePrefixConfigVerbose` shape (`{ mode, prefixes? }`). The lib
+* normalizes both to a string `mode` internally.
+*/
+type LocalePrefixValue = "always" | "as-needed" | "never" | {
+	mode?: "always" | "as-needed" | "never";
+};
+type PageRouting = {
+	locales: readonly string[];
+	defaultLocale: string;
+	localePrefix?: LocalePrefixValue;
+	/** Optional human-readable labels per locale (used by the
+	* `<LocaleSwitcher>`). Falls back to the locale code when missing.
+	* Not part of next-intl's `defineRouting` shape — the host extends
+	* its routing object to include it (e.g. via a type assertion). */
+	labels?: Record<string, string>;
+};
+type MetadataOptions = {
+	urlPrefix?: string;
+	/** When true (default), the lib generates a `{type:'website'}` JSON-LD
+	* entry per page. Pass an array to specify entries; pass `false` to
+	* skip. */
+	jsonLd?: boolean | JsonLdEntry[];
+	changefreq?: MetadataRoute.Sitemap[number]["changeFrequency"];
+	priority?: number;
+	/**
+	* Override the default `'website'` JSON-LD's `name` field. Only
+	* relevant when `jsonLd !== false` and no `name` is set on the
+	* auto-generated entry.
+	*/
+	websiteName?: string;
+};
+type ShowcaseOptions = {
+	/**
+	* Wrap the rendered page in a two-column layout with a sidebar
+	* that surfaces the page's metadata, JSON-LD, and a language
+	* switcher. Hosts that want a clean render (no sidebar) leave
+	* this `false` (the default). The demo's home page enables it
+	* so visitors can see every artifact the lib generates in one
+	* place.
+	*/
+	enabled?: boolean;
+	/** Heading shown above the metadata block. Default: `'Page metadata'`. */
+	metadataHeading?: string;
+	/** Heading shown above the JSON-LD block. Default: `'JSON-LD'`. */
+	jsonLdHeading?: string;
+};
+type CreateCollectionPageExportsArgs<S extends string = "pages"> = {
+	config: Promise<SanitizedConfig2>;
+	/**
+	* Defaults to `'pages'`. The collection slug whose documents the
+	* page route renders.
+	*/
+	slug?: S;
+	/**
+	* The next-intl `defineRouting({...})` result from the host's
+	* `i18n/routing.ts`. Drives locale validation, URL building,
+	* hreflang alternates, and the language switcher.
+	*/
+	routing: PageRouting;
+	/**
+	* The host's Payload importMap. The lib uses this to resolve
+	* the collection's `custom.path` (the page renderer module) and
+	* the live-preview listener. Pass `import { importMap } from
+	* '@/app/(payload)/admin/importMap.js'` from the host's page
+	* file. Default: `{}` — the page renders without a live-preview
+	* listener and uses the lib's registered `custom.path` for the
+	* collection renderer (which requires its key to be in the
+	* supplied importMap).
+	*/
+	importMap?: ImportMap;
+	/**
+	* Optional custom path pointing at the host's render module for
+	* the collection. Overrides the lib's registered `custom.path`
+	* (which defaults to `PAGES_RENDER_PATH`). Use this when you've
+	* defined your own Server Component for the collection.
+	*/
+	renderPath?: string;
+};
+type CreateCollectionPageExportsDeps<S extends string> = {
+	/**
+	* Host's `getServerSideURL()` (returns the absolute site URL).
+	*/
+	getServerSideURL: () => string;
+	/**
+	* Host's `generateMeta({ doc, url, type, locale })` (returns Next.js
+	* `Metadata`). The `doc` is the host's typed collection document
+	* (e.g. `Post` for the posts collection, `Page` for pages) with
+	* localized fields already resolved for the active locale. Read
+	* `doc.title` directly as a string — no locale-lookup needed.
+	*/
+	generateMeta: (args: {
+		doc: DataFromCollectionSlug<S> | null;
+		url: string;
+		type: "website" | "article";
+		locale: string;
+	}) => Promise<Metadata>;
+	/**
+	* Override the metadata type passed to `generateMeta` and the
+	* JSON-LD entry default. Defaults to `'article'` for the
+	* `posts` collection, `'website'` everywhere else. Hosts that
+	* want to opt out (e.g. treat a Post like a WebPage) pass
+	* `'website'` explicitly here.
+	*/
+	metadataType?: "website" | "article";
+	/**
+	* Optional showcase configuration. When `enabled: true`, the
+	* default page renders inside a `<PageShowcase>` sidebar that
+	* surfaces the page's metadata, JSON-LD, and a language
+	* switcher — useful for demos and CMS previews. Default: off.
+	*/
+	showcase?: ShowcaseOptions;
+	/**
+	* Optional content injected after the rendered doc body when the
+	* page is the home route (slug = `''`). The lib calls the
+	* function with the resolved locale and the current doc (or
+	* `null` if no home doc exists). Hosts that want the home to
+	* surface additional content — recent pages, recent posts,
+	* navigation — pass a function here. The return value is
+	* rendered as a sibling of the lib's doc body inside the page
+	* (and inside the showcase's main column when showcase is on).
+	*/
+	homeExtras?: (args: {
+		locale: string;
+		doc: DataFromCollectionSlug<S> | null;
+	}) => ReactNode | Promise<ReactNode>;
+};
+/**
+* Build a Pages (or any collection) page route's exports:
+* `default` (the Page Server Component), `generateMetadata`,
+* `generateStaticParams`, and `generateSitemap`.
+*
+* Designed for a next-intl layout: the page lives at
+* `app/(frontend)/[locale]/[...slug]/page.tsx`. The catch-all slug
+* handles both the home route (slug=[]) and any other doc. The lib
+* reads `params.locale` and `params.slug` (string[]), validates
+* the locale against `routing.locales`, fetches the doc, generates
+* metadata + JSON-LD + hreflang alternates, and renders the
+* resolved output.
+*
+* The host's `next-intl/routing` config is the single source of
+* truth for the locale list and URL shape.
+*
+*   // app/(frontend)/[locale]/[...slug]/page.tsx
+*   import { routing } from '@/i18n/routing'
+*   import { createCollectionPageExports } from '@justanarthur/payload-www/render-pages'
+*
+*   const { default: Page, generateMetadata, generateStaticParams } =
+*     createCollectionPageExports(
+*       { config: configPromise, routing },
+*       { getServerSideURL, generateMeta, showcase: { enabled: true } }
+*     )
+*
+*   { generateMetadata, generateStaticParams }
+*   Page
+*/
+declare function createCollectionPageExports<S extends string = "pages">({ slug, config: configPromise, routing, importMap: importMapArg, renderPath }: CreateCollectionPageExportsArgs<S>, deps: CreateCollectionPageExportsDeps<S>, options?: MetadataOptions): {
+	default: (props: {
+		params: Promise<{
+			locale?: string;
+			slug?: string[];
+		}>;
+		searchParams?: Promise<Record<string, string | string[] | undefined>>;
+	}) => Promise<ReactElement4>;
+	generateMetadata: (props: {
+		params: Promise<{
+			locale?: string;
+			slug?: string[];
+		}>;
+	}) => Promise<Metadata>;
+	generateStaticParams: () => Promise<Array<{
+		slug?: string[];
+		locale: string;
+	}>>;
+	generateSitemap: () => Promise<MetadataRoute.Sitemap>;
+	generateJsonLd: (slugSegments: string[], doc: DataFromCollectionSlug<S>, locale: string) => Promise<JsonLdOutput[]>;
+};
+declare function addCollectionsToSitemap(exports: Array<{
+	default: () => Promise<MetadataRoute.Sitemap>;
+	generateSitemap: () => Promise<MetadataRoute.Sitemap>;
+}>): {
+	default: () => Promise<MetadataRoute.Sitemap>;
+	generateSitemap: () => Promise<MetadataRoute.Sitemap>;
+};
+declare const _default: {
+	createCollectionPageExports: typeof createCollectionPageExports;
+	addCollectionsToSitemap: typeof addCollectionsToSitemap;
+	PagesPage: typeof PagesPage;
+	HeaderPage: typeof HeaderPage;
+	FooterPage: typeof FooterPage;
+};
+export { _default as default, createCollectionPageExports, addCollectionsToSitemap, PagesPage, PageExtendProps, MetadataOptions, JsonLdOutput, JsonLdEntry, HeaderPage, FooterPage, CreateCollectionPageExportsDeps, CreateCollectionPageExportsArgs };