@justanarthur/payload-www 0.1.1

package/dist/config.js

@@ -0,0 +1,914 @@
+
+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/core/access/index.ts
+var anyone = () => true;
+var authenticated = ({ req: { user } }) => Boolean(user);
+var authenticatedOrPublished = ({ req: { user } }) => {
+  if (user)
+    return true;
+  return { _status: { equals: "published" } };
+};
+
+// src/render/_locale.ts
+function prefixFor(locale, defaultLocale, mode) {
+  if (mode === "never")
+    return "";
+  if (mode === "as-needed" && locale === defaultLocale)
+    return "";
+  return `/${locale}`;
+}
+function resolveLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const r = req;
+  if (typeof r.locale === "string" && r.locale.length > 0)
+    return r.locale;
+  const fallback = r.payload?.config?.localization?.defaultLocale;
+  if (typeof fallback === "string" && fallback.length > 0)
+    return fallback;
+  return "";
+}
+function allLocales(req) {
+  if (!req || typeof req !== "object")
+    return [];
+  const r = req;
+  const list = r.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    if (typeof entry === "string" && entry.length > 0) {
+      out.push(entry);
+    } else if (entry && typeof entry === "object" && "code" in entry) {
+      const code = entry.code;
+      if (typeof code === "string" && code.length > 0)
+        out.push(code);
+    }
+  }
+  return out;
+}
+
+// src/render/hooks/_shared.ts
+var cachePromise = null;
+function nextCacheImport() {
+  return cachePromise ??= import("next/cache");
+}
+function shouldSkipRevalidate(context) {
+  return Boolean(context?.disableRevalidate);
+}
+async function safeRevalidatePath(payload, path) {
+  try {
+    const { revalidatePath } = await nextCacheImport();
+    revalidatePath(path);
+  } catch (error) {
+    payload.logger.error(`revalidatePath("${path}") failed: ${String(error)}`);
+  }
+}
+async function safeRevalidateTag(payload, tag, profile = "max") {
+  try {
+    const { revalidateTag } = await nextCacheImport();
+    revalidateTag(tag, profile);
+  } catch (error) {
+    payload.logger.error(`revalidateTag("${tag}") failed: ${String(error)}`);
+  }
+}
+
+// src/render/hooks/revalidateCollection.ts
+function createRevalidateCollectionHook(options) {
+  const {
+    collectionSlug,
+    urlPathPrefix = "",
+    sitemapTag,
+    localePrefix: modeOption,
+    defaultLocale: defaultLocaleOption,
+    pathMode = "url"
+  } = options;
+  const resolvedSitemapTag = sitemapTag === false ? false : sitemapTag ?? `${collectionSlug}-sitemap`;
+  const resolveDefaults = (req) => {
+    const mode = modeOption ?? "always";
+    const defaultLocale = defaultLocaleOption ?? req?.payload?.config?.localization?.defaultLocale ?? "";
+    return { mode, defaultLocale };
+  };
+  const localesToFanOut = (req) => {
+    const all = allLocales(req);
+    if (all.length > 0)
+      return all;
+    const single = resolveLocale(req);
+    return single ? [single] : [];
+  };
+  const collectionPath = (slug, locale, mode, defaultLocale) => {
+    const prefix = prefixFor(locale, defaultLocale, mode);
+    if (!slug)
+      return `${prefix}${urlPathPrefix}` || "/";
+    return `${prefix}${urlPathPrefix}/${slug}`;
+  };
+  const fanOutPaths = async (payload, req, slug, label) => {
+    const { mode, defaultLocale } = resolveDefaults(req);
+    const locales = localesToFanOut(req);
+    for (const locale of locales) {
+      const path = collectionPath(slug, locale, mode, defaultLocale);
+      payload.logger.info?.(`${label} ${path}`);
+      await safeRevalidatePath(payload, path);
+    }
+  };
+  const fireCollectionTags = async (payload, docId, req) => {
+    if (typeof docId === "string" || typeof docId === "number") {
+      await safeRevalidateTag(payload, `collection_${collectionSlug}_${docId}`);
+    }
+    if (resolvedSitemapTag !== false) {
+      await safeRevalidateTag(payload, resolvedSitemapTag);
+    }
+  };
+  const afterChange = async ({ doc, previousDoc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc;
+    const { payload } = req;
+    const typed = doc;
+    const prev = previousDoc;
+    const isPublished = typed._status === "published";
+    const wasPublished = prev?._status === "published";
+    const prevSlugIsString = typeof prev?.slug === "string";
+    const slugChanged = prevSlugIsString && prev?.slug !== typed.slug;
+    if (isPublished) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, typed.slug, `Revalidating ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    if (wasPublished && (!isPublished || slugChanged)) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, prev?.slug, `Revalidating old ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    return doc;
+  };
+  const afterDelete = async ({ doc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc ?? null;
+    const { payload } = req;
+    const typed = doc;
+    if (pathMode !== "tag-only") {
+      await fanOutPaths(payload, req, typed?.slug, `Revalidating deleted ${collectionSlug} at path:`);
+    }
+    await fireCollectionTags(payload, typed?.id, req);
+    return doc ?? null;
+  };
+  return { afterChange, afterDelete };
+}
+var createRevalidatePageHooks = (opts = {}) => createRevalidateCollectionHook({
+  collectionSlug: "pages",
+  urlPathPrefix: "",
+  ...opts
+});
+
+// src/config/constants.ts
+var PAGES_RENDER_PATH = "@justanarthur/payload-www/render-pages#PagesPage";
+var POSTS_RENDER_PATH = "@justanarthur/payload-www/render-pages#PostsPage";
+var HEADER_RENDER_PATH = "@justanarthur/payload-www/render-pages#HeaderPage";
+var FOOTER_RENDER_PATH = "@justanarthur/payload-www/render-pages#FooterPage";
+var LIVE_PREVIEW_LISTENER_PATH = "@justanarthur/payload-www/render-components#LivePreviewListener";
+var PAGES_SLUG = "pages";
+var POSTS_SLUG = "posts";
+var STATIC_PAGES_SLUG = "staticPages";
+
+// src/data/collections/Pages/index.ts
+var HOME_PAGE_SLUG = "";
+var PAGES_SLUG2 = PAGES_SLUG;
+var createPagesCollection = (blocks, options = {}) => {
+  const {
+    renderPath = PAGES_RENDER_PATH,
+    slug: collectionSlug = PAGES_SLUG2,
+    localePrefix,
+    defaultLocale
+  } = options;
+  const slugField = {
+    name: "slug",
+    type: "text",
+    required: true,
+    unique: true,
+    index: true,
+    admin: { position: "sidebar" },
+    validate: (value) => {
+      if (typeof value !== "string")
+        return "Slug must be a string";
+      if (value !== "" && !/^[a-z0-9-]+$/.test(value)) {
+        return "Slug must be lowercase, with hyphens (no spaces or special characters)";
+      }
+      return true;
+    }
+  };
+  const baseFields = [
+    {
+      name: "title",
+      type: "text",
+      required: true,
+      localized: true
+    },
+    {
+      type: "tabs",
+      tabs: [
+        {
+          fields: [
+            {
+              name: "blocks",
+              type: "blocks",
+              blocks,
+              required: true,
+              admin: { initCollapsed: true }
+            }
+          ],
+          label: "Content"
+        }
+      ]
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      admin: { position: "sidebar" }
+    },
+    slugField
+  ];
+  const { afterChange: revalidateAfterChange, afterDelete: revalidateAfterDelete } = createRevalidateCollectionHook({
+    collectionSlug,
+    urlPathPrefix: "",
+    localePrefix,
+    defaultLocale
+  });
+  return {
+    slug: collectionSlug,
+    custom: { path: renderPath },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: baseFields,
+    hooks: {
+      afterChange: [revalidateAfterChange],
+      afterDelete: [revalidateAfterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/data/collections/Posts/index.ts
+var POSTS_SLUG2 = "posts";
+var createPostsCollection = (options = {}) => {
+  const {
+    renderPath = POSTS_RENDER_PATH,
+    slug: collectionSlug = POSTS_SLUG2,
+    localePrefix,
+    defaultLocale
+  } = options;
+  const slugField = {
+    name: "slug",
+    type: "text",
+    required: true,
+    unique: true,
+    index: true,
+    admin: { position: "sidebar" }
+  };
+  const baseFields = [
+    {
+      name: "title",
+      type: "text",
+      required: true,
+      localized: true
+    },
+    {
+      name: "excerpt",
+      type: "text",
+      required: false,
+      localized: true
+    },
+    {
+      name: "content",
+      type: "richText",
+      required: false,
+      localized: true
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      admin: { position: "sidebar" }
+    },
+    slugField
+  ];
+  const { afterChange, afterDelete } = createRevalidateCollectionHook({
+    collectionSlug,
+    urlPathPrefix: "/posts",
+    localePrefix,
+    defaultLocale
+  });
+  return {
+    slug: collectionSlug,
+    custom: { path: renderPath },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: baseFields,
+    hooks: {
+      afterChange: [afterChange],
+      afterDelete: [afterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/data/collections/StaticPages/index.ts
+var createStaticPagesCollection = (blocks) => {
+  const { afterChange, afterDelete } = createRevalidateCollectionHook({
+    collectionSlug: STATIC_PAGES_SLUG,
+    pathMode: "tag-only",
+    sitemapTag: "static-pages"
+  });
+  return {
+    slug: STATIC_PAGES_SLUG,
+    dbName: "sp",
+    admin: { group: "System", useAsTitle: "title" },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: [
+      {
+        name: "kind",
+        type: "select",
+        required: true,
+        unique: true,
+        index: true,
+        options: [
+          { label: "Not found (404)", value: "not-found" },
+          { label: "Server error (500)", value: "server-error" },
+          { label: "Search empty", value: "search-empty" },
+          { label: "Offline", value: "offline" }
+        ],
+        admin: {
+          position: "sidebar",
+          description: "Which system page this row powers. One row per kind."
+        }
+      },
+      {
+        name: "title",
+        type: "text",
+        required: true,
+        localized: true,
+        admin: { description: "Admin-only label. Not rendered." }
+      },
+      {
+        type: "tabs",
+        tabs: [
+          {
+            fields: [
+              {
+                name: "blocks",
+                type: "blocks",
+                localized: true,
+                blocks,
+                admin: { initCollapsed: true },
+                dbName: "b"
+              }
+            ],
+            label: "Content"
+          }
+        ]
+      },
+      {
+        name: "publishedAt",
+        type: "date",
+        admin: { position: "sidebar" }
+      }
+    ],
+    hooks: {
+      afterChange: [afterChange],
+      afterDelete: [afterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/core/fields/link.ts
+var appearanceOptions = {
+  default: { label: "Default", value: "default" },
+  outline: { label: "Outline", value: "outline" }
+};
+var link = (options = {}) => {
+  const {
+    appearances,
+    disableLabel = false,
+    relationTo = [PAGES_SLUG],
+    localized = false,
+    overrides = {}
+  } = options;
+  const result = {
+    name: "link",
+    type: "group",
+    admin: { hideGutter: true },
+    fields: [
+      {
+        type: "row",
+        fields: [
+          {
+            name: "type",
+            type: "radio",
+            admin: { layout: "horizontal", width: "50%" },
+            defaultValue: "reference",
+            options: [
+              { label: "Internal link", value: "reference" },
+              { label: "Custom URL", value: "custom" }
+            ]
+          },
+          {
+            name: "newTab",
+            type: "checkbox",
+            admin: { style: { alignSelf: "flex-end" }, width: "50%" },
+            label: "Open in new tab"
+          }
+        ]
+      }
+    ]
+  };
+  const linkTypes = [
+    {
+      name: "reference",
+      type: "relationship",
+      admin: { condition: (_, siblingData) => siblingData?.type === "reference" },
+      label: "Document to link to",
+      relationTo,
+      required: true,
+      localized
+    },
+    {
+      name: "url",
+      type: "text",
+      admin: { condition: (_, siblingData) => siblingData?.type === "custom" },
+      label: "Custom URL",
+      required: true,
+      localized
+    }
+  ];
+  if (!disableLabel) {
+    result.fields.push({
+      type: "row",
+      fields: [
+        ...linkTypes,
+        {
+          name: "label",
+          type: "text",
+          admin: { width: "50%" },
+          label: "Label",
+          required: true,
+          localized
+        }
+      ]
+    });
+  } else {
+    result.fields = [...result.fields, ...linkTypes];
+  }
+  if (appearances !== false) {
+    const opts = appearances ? appearances.map((a) => appearanceOptions[a]) : [appearanceOptions.default, appearanceOptions.outline];
+    result.fields.push({
+      name: "appearance",
+      type: "select",
+      admin: { description: "Choose how the link should be rendered." },
+      defaultValue: "default",
+      options: opts
+    });
+  }
+  return { ...result, ...overrides };
+};
+
+// src/render/hooks/revalidateGlobal.ts
+function createRevalidateGlobalHook(slug) {
+  return async ({ doc, req: { payload, context, locale } }) => {
+    if (shouldSkipRevalidate(context))
+      return doc;
+    const tags = [`global_${slug}`, `global_${slug}_${locale}`];
+    payload.logger.info?.(`Revalidating global: ${tags.join(", ")}`);
+    for (const tag of tags) {
+      await safeRevalidateTag(payload, tag);
+    }
+    return doc;
+  };
+}
+
+// src/data/collections/globals/Header/config.ts
+var createHeaderGlobal = (options = {}) => {
+  const { renderPath = HEADER_RENDER_PATH, linkRelationTo = [PAGES_SLUG] } = options;
+  const navColumnBlock = {
+    slug: "navColumn",
+    fields: [
+      { name: "title", type: "text", required: true, localized: true },
+      { name: "links", type: "array", fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })] }
+    ]
+  };
+  const navItemBlock = {
+    slug: "navItem",
+    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })]
+  };
+  return {
+    slug: "header",
+    custom: { path: renderPath },
+    access: { read: () => true },
+    fields: [
+      {
+        name: "nav",
+        type: "blocks",
+        required: true,
+        blocks: [navColumnBlock, navItemBlock]
+      }
+    ],
+    hooks: {
+      afterChange: [createRevalidateGlobalHook("header")]
+    }
+  };
+};
+
+// src/data/collections/globals/Footer/config.ts
+var createFooterGlobal = (options = {}) => {
+  const { renderPath = FOOTER_RENDER_PATH, linkRelationTo = [PAGES_SLUG] } = options;
+  const navColumnBlock = {
+    slug: "navColumn",
+    fields: [
+      { name: "title", type: "text", required: true, localized: true },
+      { name: "links", type: "array", fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })] }
+    ]
+  };
+  const navItemBlock = {
+    slug: "navItem",
+    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })]
+  };
+  return {
+    slug: "footer",
+    custom: { path: renderPath },
+    access: { read: () => true },
+    fields: [
+      {
+        name: "nav",
+        type: "blocks",
+        required: true,
+        blocks: [navColumnBlock, navItemBlock]
+      }
+    ],
+    hooks: {
+      afterChange: [createRevalidateGlobalHook("footer")]
+    }
+  };
+};
+
+// src/config/createWWWConfig.ts
+import openAIResolver from "@justanarthur/payload-plugin-translator/resolvers/openAI";
+
+// src/render/preview/createPreviewHandler.ts
+function createPreviewHandler(options) {
+  const { getServerSideURL: _getServerSideURL, secret, enableDraftMode = true } = options;
+  return async function GET(req) {
+    const { draftMode } = await import("next/headers");
+    const { redirect } = await import("next/navigation");
+    const url = new URL(req.url);
+    const path = url.searchParams.get("path") ?? "/";
+    const previewSecret = url.searchParams.get("previewSecret");
+    if (!previewSecret || previewSecret !== secret) {
+      return new Response("Invalid preview secret", { status: 401 });
+    }
+    if (enableDraftMode) {
+      (await draftMode()).enable();
+    }
+    redirect(path);
+    return new Response(null, { status: 204 });
+  };
+}
+// 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/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/render/sitemap/createSitemapFile.ts
+function createSitemapFile(options) {
+  const { collections } = options;
+  return async function sitemap() {
+    const cfg = await options.config;
+    const allLocales2 = Array.isArray(cfg.localization?.locales) ? cfg.localization.locales.map((l) => typeof l === "string" ? l : l.code) : [cfg.localization?.defaultLocale ?? "en"];
+    const defaultLocale = cfg.localization?.defaultLocale ?? allLocales2[0];
+    const activeLocales = Array.isArray(options.locales) && options.locales.length > 0 ? options.locales.filter((l) => allLocales2.includes(l)) : allLocales2;
+    const entries = [];
+    const seen = new Set;
+    for (const collectionSlug of collections) {
+      const collectionDefaults = options.perCollection?.[collectionSlug] ?? {};
+      const urlPrefix = (options.urlPrefixes?.[collectionSlug] ?? "").replace(/\/$/, "");
+      const siteUrl = options.getServerSideURL().replace(/\/$/, "");
+      for (const locale of activeLocales) {
+        const docs = await queryAllDocs({
+          collectionSlug,
+          slugField: "slug",
+          locale,
+          config: options.config
+        });
+        for (const doc of docs) {
+          const storedSlug = doc.slug;
+          if (typeof storedSlug !== "string" || storedSlug === "")
+            continue;
+          const dedupeKey = `${collectionSlug}:${locale}:${storedSlug}`;
+          if (seen.has(dedupeKey))
+            continue;
+          seen.add(dedupeKey);
+          const url = `${siteUrl}${prefixFor(locale, defaultLocale, options.localePrefix ?? "always")}${urlPrefix}/${storedSlug}`;
+          const languages = await buildHreflangAlternates({
+            siteUrl,
+            locale,
+            urlPrefix,
+            storedSlug,
+            nested: false,
+            homeSlug: "",
+            defaultLocale,
+            locales: activeLocales,
+            localePrefix: options.localePrefix,
+            queryAllLocaleSlugs: async (s, l) => {
+              const result = await queryAllLocaleSlugs({
+                collectionSlug,
+                slug: s,
+                slugField: "slug",
+                locale: l,
+                config: options.config
+              });
+              return result ?? undefined;
+            }
+          });
+          entries.push({
+            url,
+            lastModified: doc.updatedAt ? new Date(doc.updatedAt) : undefined,
+            changeFrequency: collectionDefaults.changefreq ?? "weekly",
+            priority: collectionDefaults.priority ?? 0.5,
+            alternates: { languages }
+          });
+        }
+      }
+    }
+    return entries;
+  };
+}
+// src/config/createWWWConfig.ts
+function createWWWConfig(options) {
+  const { locales, routing, blocks, linkRelationTo, registerPosts = true, defaultPlugins } = options;
+  const defaultLocale = routing?.defaultLocale ?? locales[0] ?? "";
+  const localePrefixMode = (() => {
+    const raw = routing?.localePrefix;
+    if (typeof raw === "string")
+      return raw;
+    return raw?.mode ?? "always";
+  })();
+  if (locales.length === 0) {
+    throw new Error("createWWWConfig: `locales` must contain at least one entry.");
+  }
+  const buildPagesCollection = () => createPagesCollection(blocks, {
+    localePrefix: localePrefixMode,
+    defaultLocale
+  });
+  const buildPostsCollection = () => createPostsCollection({
+    localePrefix: localePrefixMode,
+    defaultLocale
+  });
+  const buildStaticPagesCollection = () => createStaticPagesCollection(blocks);
+  const buildHeaderGlobal = () => createHeaderGlobal({ linkRelationTo });
+  const buildFooterGlobal = () => createFooterGlobal({ linkRelationTo });
+  async function withWWWConfig(config) {
+    const baseDefaults = [
+      buildPagesCollection(),
+      buildStaticPagesCollection()
+    ];
+    if (registerPosts)
+      baseDefaults.push(buildPostsCollection());
+    const defaultCollections = baseDefaults;
+    const collections = typeof config.collections === "function" ? config.collections({ defaultCollections }) : [...defaultCollections, ...config.collections || []];
+    const defaultGlobals = [buildHeaderGlobal(), buildFooterGlobal()];
+    const globals = typeof config.globals === "function" ? config.globals({ defaultGlobals }) : [...defaultGlobals, ...config.globals || []];
+    const renderDependencies = {
+      [PAGES_RENDER_PATH]: { path: PAGES_RENDER_PATH, type: "component" },
+      [POSTS_RENDER_PATH]: { path: POSTS_RENDER_PATH, type: "component" },
+      [HEADER_RENDER_PATH]: { path: HEADER_RENDER_PATH, type: "component" },
+      [FOOTER_RENDER_PATH]: { path: FOOTER_RENDER_PATH, type: "component" },
+      [LIVE_PREVIEW_LISTENER_PATH]: {
+        path: LIVE_PREVIEW_LISTENER_PATH,
+        type: "component"
+      }
+    };
+    for (const { slug, admin } of blocks) {
+      const path = admin?.custom?.path;
+      if (typeof path === "string" && slug)
+        renderDependencies[slug] = { path, type: "component" };
+    }
+    for (const entry of [...collections, ...globals]) {
+      const path = entry.custom?.path;
+      if (typeof path === "string")
+        renderDependencies[path] = { path, type: "component" };
+    }
+    const [
+      { seoPlugin },
+      { imageHashPlugin },
+      { translator }
+    ] = await Promise.all([
+      import("@justanarthur/payload-plugin-seo"),
+      import("@justanarthur/payload-imagehash-plugin"),
+      import("@justanarthur/payload-plugin-translator")
+    ]);
+    const defaultPluginList = [
+      seoPlugin({
+        collections: ["pages", "posts", "static-pages"],
+        autoGenerate: { mode: "onCreate", deriveFrom: "allScalars" }
+      }),
+      imageHashPlugin({ algorithm: "lqip-modern" }),
+      translator({
+        collections: ["pages", "posts", "static-pages"],
+        globals: ["header", "footer"],
+        resolvers: [
+          openAIResolver({
+            apiKey: process.env.OPENAI_API_KEY,
+            chunkLength: 31,
+            model: "gpt-5-mini"
+          })
+        ]
+      })
+    ];
+    const mergedPlugins = defaultPlugins ? defaultPlugins(defaultPluginList) : defaultPluginList;
+    return {
+      ...config,
+      collections,
+      globals,
+      plugins: mergedPlugins,
+      admin: {
+        ...config.admin ?? {},
+        dependencies: {
+          ...renderDependencies,
+          ...config.admin?.dependencies ?? {}
+        }
+      }
+    };
+  }
+  return { withWWWConfig };
+}
+
+// src/exports/config.ts
+var config_default = createWWWConfig;
+export {
+  config_default as default,
+  createWWWConfig
+};