@justanarthur/payload-www 0.1.1

package/dist/render-components.d.ts

@@ -0,0 +1,42 @@
+import { FC } from "react";
+type LivePreviewListenerProps = {
+	serverURL?: string;
+};
+declare const LivePreviewListener: FC<LivePreviewListenerProps>;
+import { FC as FC2 } from "react";
+type AdminBarLabels = {
+	/** Trigger button label (when popover is closed). */
+	trigger?: string;
+	/** Exit-preview link label. */
+	exitPreview?: string;
+	/** Tooltip / a11y description for the trigger button. */
+	triggerHint?: string;
+};
+type AdminBarProps = {
+	/**
+	* Whether draft mode is currently active. When `false`, the
+	* component renders `null` — zero DOM cost in production.
+	*/
+	preview: boolean;
+	/**
+	* Path to navigate to when the host clicks "Exit preview". Defaults
+	* to `/next/exit-preview` (matches Payload's standard handler).
+	*/
+	exitPreviewPath?: string;
+	/**
+	* Per-label overrides for i18n hosts. Defaults are English.
+	*/
+	labels?: AdminBarLabels;
+};
+/**
+* Next.js App Router–style draft-mode admin bar. Renders only when
+* `preview` is true; shows a small floating button in the bottom-right
+* that opens a native `<dialog>` popover with an "Exit preview" link.
+*
+* Mirrors `LivePreviewListener` as a self-contained `'use client'`
+* component the host drops into the layout's providers tree. No
+* dependency on `@payloadcms/admin-bar` — pure React + a few
+* Tailwind-free inline styles so hosts can theme freely.
+*/
+declare const AdminBar: FC2<AdminBarProps>;
+export { LivePreviewListener as default, LivePreviewListenerProps, LivePreviewListener, AdminBarProps, AdminBarLabels, AdminBar };

package/dist/render-components.js

@@ -0,0 +1,144 @@
+"use client";
+
+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/components/LivePreviewListener.tsx
+import { RefreshRouteOnSave as PayloadLivePreview } from "@payloadcms/live-preview-react";
+import { useRouter } from "next/navigation";
+import { jsx } from "react/jsx-runtime";
+
+var LivePreviewListener = ({ serverURL }) => {
+  const router = useRouter();
+  const url = serverURL ?? process.env.NEXT_PUBLIC_SERVER_URL ?? (typeof window !== "undefined" ? window.location.origin : "");
+  return /* @__PURE__ */ jsx(PayloadLivePreview, {
+    refresh: router.refresh,
+    serverURL: url
+  });
+};
+
+// src/render/components/AdminBar.tsx
+import { useRouter as useRouter2 } from "next/navigation";
+import { useState } from "react";
+import { jsx as jsx2, jsxs, Fragment } from "react/jsx-runtime";
+
+var defaultLabels = {
+  trigger: "Preview",
+  exitPreview: "Exit preview",
+  triggerHint: "Open draft-mode admin bar"
+};
+var AdminBar = ({ preview, exitPreviewPath = "/next/exit-preview", labels }) => {
+  const router = useRouter2();
+  const [open, setOpen] = useState(false);
+  const merged = { ...defaultLabels, ...labels };
+  if (!preview)
+    return null;
+  return /* @__PURE__ */ jsxs(Fragment, {
+    children: [
+      /* @__PURE__ */ jsx2("button", {
+        type: "button",
+        onClick: () => setOpen(true),
+        title: merged.triggerHint,
+        style: {
+          position: "fixed",
+          bottom: 16,
+          right: 16,
+          zIndex: 2147483647,
+          padding: "8px 14px",
+          borderRadius: 9999,
+          border: "1px solid rgba(0,0,0,0.12)",
+          background: "#111",
+          color: "#fff",
+          fontSize: 12,
+          fontWeight: 600,
+          letterSpacing: 0.4,
+          textTransform: "uppercase",
+          cursor: "pointer",
+          boxShadow: "0 4px 16px rgba(0,0,0,0.18)"
+        },
+        children: merged.trigger
+      }),
+      /* @__PURE__ */ jsx2("dialog", {
+        open,
+        onClose: () => setOpen(false),
+        onClick: (e) => {
+          if (e.target === e.currentTarget)
+            setOpen(false);
+        },
+        style: {
+          position: "fixed",
+          inset: 0,
+          width: "100vw",
+          height: "100vh",
+          maxWidth: "100vw",
+          maxHeight: "100vh",
+          margin: 0,
+          padding: 0,
+          border: "none",
+          background: "rgba(0,0,0,0.32)",
+          zIndex: 2147483647
+        },
+        children: /* @__PURE__ */ jsxs("div", {
+          style: {
+            position: "absolute",
+            bottom: 24,
+            right: 24,
+            minWidth: 220,
+            padding: 16,
+            borderRadius: 8,
+            background: "#fff",
+            color: "#111",
+            boxShadow: "0 12px 36px rgba(0,0,0,0.24)"
+          },
+          onClick: (e) => e.stopPropagation(),
+          children: [
+            /* @__PURE__ */ jsx2("div", {
+              style: { fontSize: 13, fontWeight: 600, marginBottom: 8 },
+              children: merged.trigger
+            }),
+            /* @__PURE__ */ jsx2("div", {
+              style: { fontSize: 12, color: "#666", marginBottom: 12 },
+              children: "Draft mode is on. Edits in Payload will refresh this view automatically."
+            }),
+            /* @__PURE__ */ jsx2("a", {
+              href: exitPreviewPath,
+              onClick: () => router.refresh(),
+              style: {
+                display: "inline-block",
+                padding: "6px 10px",
+                borderRadius: 6,
+                background: "#111",
+                color: "#fff",
+                fontSize: 12,
+                fontWeight: 600,
+                textDecoration: "none"
+              },
+              children: merged.exitPreview
+            })
+          ]
+        })
+      })
+    ]
+  });
+};
+
+// src/exports/render-components.ts
+var render_components_default = LivePreviewListener;
+export {
+  render_components_default as default,
+  LivePreviewListener,
+  AdminBar
+};

package/dist/render-metadata.d.ts

@@ -0,0 +1,122 @@
+type ArticleLdOptions = {
+	doc: Record<string, any>;
+	url: string;
+	locale: string;
+	siteUrl: string;
+	type?: "BlogPosting" | "Article" | "NewsArticle" | "TechArticle";
+	publisherName?: string;
+	publisherLogo?: string | null;
+};
+declare function buildArticleLd({ doc, url, locale, siteUrl, type, publisherName, publisherLogo }: ArticleLdOptions): Record<string, unknown>;
+type BreadcrumbItem = {
+	label: string;
+	url: string;
+};
+declare function buildBreadcrumbsLd({ items, currentUrl }: {
+	items: BreadcrumbItem[];
+	currentUrl: string;
+}): Record<string, unknown>;
+declare function buildOrganizationLd({ siteUrl, name, logo, sameAs }: {
+	siteUrl: string;
+	name?: string;
+	logo?: string;
+	sameAs?: string[];
+}): Record<string, unknown>;
+declare function buildHreflangAlternates<L extends string>({ siteUrl, locale, urlPrefix, storedSlug, queryAllLocaleSlugs, nested, homeSlug, defaultLocale, locales, localePrefix }: {
+	siteUrl: string;
+	locale: L;
+	urlPrefix: string;
+	storedSlug: string;
+	queryAllLocaleSlugs: (slug: string, locale: L) => Promise<Partial<Record<L, string>> | undefined>;
+	nested: boolean;
+	homeSlug: string;
+	defaultLocale: L;
+	locales: readonly L[];
+	/**
+	* Locale prefix mode — mirrors next-intl's `localePrefix` so each
+	* alternate URL matches the host's actual route shape:
+	*
+	* - `'always'`: every URL is prefixed with `/{locale}/…`
+	*   (e.g. `/en/about`, `/uk/about`). The default — preserves
+	*   the helper's prior behavior.
+	* - `'as-needed'`: the default locale renders without a prefix
+	*   (e.g. `/about`), other locales are prefixed (`/uk/about`).
+	*   Critical: callers that emit hreflang alongside a canonical
+	*   URL built with `as-needed` mode MUST pass this through,
+	*   otherwise the `en` and `x-default` alternates point to URLs
+	*   the host doesn't actually serve.
+	* - `'never'`: no locale prefix at all.
+	*/
+	localePrefix?: "always" | "as-needed" | "never";
+}): Promise<Record<string, string>>;
+declare function segmentsToStoredSlug(segments: string[] | string, nested?: boolean): string;
+declare function segmentsToUrlPath(segments: string[] | string, nested?: boolean): string;
+declare function storedSlugToSegments(storedSlug: string, nested?: boolean): string[] | string;
+declare function buildCanonicalUrl<L extends string>({ siteUrl, locale, urlPrefix, urlPath }: {
+	siteUrl: string;
+	locale: L;
+	urlPrefix: string;
+	urlPath: string;
+}): string;
+declare function getUrlPath(segments: string[] | string, nested: boolean, homeSlug: string): string;
+import { DataFromCollectionSlug, ImportMap, SanitizedConfig } from "payload";
+declare const queryDocBySlug: <S extends string>({ collectionSlug, slug, slugField, locale, draft, config }: {
+	collectionSlug: S;
+	slug: string;
+	slugField?: string;
+	locale: string;
+	draft?: boolean;
+	config: Promise<SanitizedConfig>;
+}) => Promise<DataFromCollectionSlug<S> | null>;
+declare const queryAllDocs: <S extends string>({ collectionSlug, slugField, locale, config }: {
+	collectionSlug: S;
+	slugField?: string;
+	locale: string;
+	config: Promise<SanitizedConfig>;
+}) => Promise<DataFromCollectionSlug<S>[]>;
+declare const queryAllLocaleSlugs2: <S extends string>({ collectionSlug, slug, slugField, locale, config }: {
+	collectionSlug: S;
+	slug: string;
+	slugField?: string;
+	locale: string;
+	config: Promise<SanitizedConfig>;
+}) => Promise<Record<string, string> | undefined>;
+declare function getRenderModuleExports(exportName: string, collection: {
+	custom?: Record<string, unknown>;
+} | undefined, importMap: ImportMap): unknown;
+import { SanitizedConfig as SanitizedConfig_ee8ogz } from "payload";
+import { DataFromCollectionSlug as DataFromCollectionSlug_2e2bqb } from "payload";
+declare const _default: {
+	buildArticleLd: typeof buildArticleLd;
+	buildBreadcrumbsLd: typeof buildBreadcrumbsLd;
+	buildOrganizationLd: typeof buildOrganizationLd;
+	buildHreflangAlternates: typeof buildHreflangAlternates;
+	queryDocBySlug: <S extends string>({ collectionSlug, slug, slugField, locale, draft, config }: {
+		collectionSlug: S;
+		slug: string;
+		slugField?: string;
+		locale: string;
+		draft?: boolean;
+		config: Promise<SanitizedConfig_ee8ogz>;
+	}) => Promise<DataFromCollectionSlug_2e2bqb<S> | null>;
+	queryAllDocs: <S extends string>({ collectionSlug, slugField, locale, config }: {
+		collectionSlug: S;
+		slugField?: string;
+		locale: string;
+		config: Promise<SanitizedConfig_ee8ogz>;
+	}) => Promise<DataFromCollectionSlug_2e2bqb<S>[]>;
+	queryAllLocaleSlugs2: <S extends string>({ collectionSlug, slug, slugField, locale, config }: {
+		collectionSlug: S;
+		slug: string;
+		slugField?: string;
+		locale: string;
+		config: Promise<SanitizedConfig_ee8ogz>;
+	}) => Promise<Record<string, string> | undefined>;
+	getUrlPath: typeof getUrlPath;
+	segmentsToStoredSlug: typeof segmentsToStoredSlug;
+	segmentsToUrlPath: typeof segmentsToUrlPath;
+	storedSlugToSegments: typeof storedSlugToSegments;
+	buildCanonicalUrl: typeof buildCanonicalUrl;
+	getRenderModuleExports: typeof getRenderModuleExports;
+};
+export { storedSlugToSegments, segmentsToUrlPath, segmentsToStoredSlug, queryDocBySlug, queryAllLocaleSlugs2 as queryAllLocaleSlugs, queryAllDocs, getUrlPath, getRenderModuleExports, _default as default, buildOrganizationLd, buildHreflangAlternates, buildCanonicalUrl, buildBreadcrumbsLd, buildArticleLd, BreadcrumbItem, ArticleLdOptions };

package/dist/render-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/render-metadata.ts
+var render_metadata_default = {
+  buildArticleLd,
+  buildBreadcrumbsLd,
+  buildOrganizationLd,
+  buildHreflangAlternates,
+  queryDocBySlug,
+  queryAllDocs,
+  queryAllLocaleSlugs,
+  getUrlPath,
+  segmentsToStoredSlug,
+  segmentsToUrlPath,
+  storedSlugToSegments,
+  buildCanonicalUrl,
+  getRenderModuleExports
+};
+export {
+  storedSlugToSegments,
+  segmentsToUrlPath,
+  segmentsToStoredSlug,
+  queryDocBySlug,
+  queryAllLocaleSlugs,
+  queryAllDocs,
+  getUrlPath,
+  getRenderModuleExports,
+  render_metadata_default as default,
+  buildOrganizationLd,
+  buildHreflangAlternates,
+  buildCanonicalUrl,
+  buildBreadcrumbsLd,
+  buildArticleLd
+};