@justanarthur/payload-www 0.3.4 → 1.0.1

package/dist/collections.js

@@ -1,697 +1,222 @@
 
-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 = () => {
-  console.log("[WWW] core/access:anyone -> true");
-  return true;
-};
-var authenticated = ({ req: { user } }) => {
-  const result = Boolean(user);
-  console.log("[WWW] core/access:authenticated ->", result);
-  return result;
-};
-var authenticatedOrPublished = ({ req: { user } }) => {
-  if (user) {
-    console.log("[WWW] core/access:authenticatedOrPublished -> true (authenticated)");
-    return true;
-  }
-  console.log('[WWW] core/access:authenticatedOrPublished -> { _status: { equals: "published" } }');
-  return { _status: { equals: "published" } };
-};
-
-// src/core/fields/slug.ts
-var FLAT_PATTERN = /^[a-z0-9-]+$/;
-var NESTED_PATTERN = /^[a-z0-9_-]+$/;
-var slugField = (options = {}) => {
-  const { name = "slug", nested = false, localized = true } = options;
-  const pattern = nested ? NESTED_PATTERN : FLAT_PATTERN;
-  const invalidMessage = nested ? "Slug must be lowercase, with hyphens or the `_` nesting divider (no spaces or other special characters)" : "Slug must be lowercase, with hyphens (no spaces or special characters)";
-  console.log("[WWW] core/fields:slugField options=", JSON.stringify({ name, nested, localized }));
-  return {
-    name,
-    type: "text",
-    required: true,
-    unique: true,
-    index: true,
-    localized,
-    admin: {
-      position: "sidebar",
-      ...nested ? { description: "Lowercase, hyphens for words. Use the `_` divider for nesting, e.g. `about_us` → `/about/us`." } : {}
-    },
-    validate: (value) => {
-      if (typeof value !== "string")
-        return "Slug must be a string";
-      if (value !== "" && !pattern.test(value)) {
-        console.warn("[WWW] core/fields:slugField invalid slug value=", JSON.stringify(value));
-        return invalidMessage;
-      }
-      return true;
-    }
-  };
-};
-
-// src/render/_locale.ts
-function prefixFor(locale, defaultLocale, mode) {
-  let result;
-  if (mode === "never")
-    result = "";
-  else if (mode === "as-needed" && locale === defaultLocale)
-    result = "";
-  else
-    result = `/${locale}`;
-  console.log("[WWW] render/_locale:prefixFor locale=", locale, "default=", defaultLocale, "mode=", mode, "->", JSON.stringify(result));
-  return result;
-}
-function resolveLocale(req) {
-  if (!req || typeof req !== "object") {
-    console.log('[WWW] render/_locale:resolveLocale -> "" (no req)');
-    return "";
-  }
-  const r = req;
-  if (typeof r.locale === "string" && r.locale.length > 0) {
-    console.log("[WWW] render/_locale:resolveLocale ->", r.locale, "(from req.locale)");
-    return r.locale;
-  }
-  const fallback = r.payload?.config?.localization?.defaultLocale;
-  if (typeof fallback === "string" && fallback.length > 0) {
-    console.log("[WWW] render/_locale:resolveLocale ->", fallback, "(from config.localization.defaultLocale)");
-    return fallback;
-  }
-  console.log('[WWW] render/_locale:resolveLocale -> "" (no locale anywhere)');
-  return "";
-}
-function allLocales(req) {
-  if (!req || typeof req !== "object") {
-    console.log("[WWW] render/_locale:allLocales -> [] (no req)");
-    return [];
-  }
-  const r = req;
-  const list = r.payload?.config?.localization?.locales;
-  if (!Array.isArray(list) || list.length === 0) {
-    console.log("[WWW] render/_locale:allLocales -> [] (no locales declared)");
-    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);
+// package.json
+var name = "@justanarthur/payload-www";
+
+// src/collections/hooks/populatePublishedAt.ts
+var populatePublishedAt = ({ data, operation, req }) => {
+  if (operation === "create" || operation === "update") {
+    if (req.data && !req.data.publishedAt) {
+      const now = new Date;
+      return {
+        ...data,
+        publishedAt: now
+      };
     }
   }
-  console.log("[WWW] render/_locale:allLocales ->", JSON.stringify(out));
-  return out;
-}
-
-// src/render/hooks/_shared.ts
-var cachePromise = null;
-function nextCacheImport() {
-  return cachePromise ??= import("next/cache");
-}
-function shouldSkipRevalidate(context) {
-  const skip = Boolean(context?.disableRevalidate);
-  if (skip)
-    console.log("[WWW] render/hooks:_shared:shouldSkipRevalidate -> skip");
-  return skip;
-}
-async function safeRevalidatePath(payload, path) {
-  console.log("[WWW] render/hooks:_shared:safeRevalidatePath path=", path);
-  try {
-    const { revalidatePath } = await nextCacheImport();
-    revalidatePath(path);
-  } catch (error) {
-    console.error("[WWW] render/hooks:_shared:safeRevalidatePath failed path=", path, "err=", String(error));
-    payload.logger.error(`revalidatePath("${path}") failed: ${String(error)}`);
-  }
-}
-async function safeRevalidateTag(payload, tag, profile = "max") {
-  console.log("[WWW] render/hooks:_shared:safeRevalidateTag tag=", tag, "profile=", profile);
-  try {
-    const { revalidateTag } = await nextCacheImport();
-    revalidateTag(tag, profile);
-  } catch (error) {
-    console.error("[WWW] render/hooks:_shared:safeRevalidateTag failed tag=", tag, "err=", String(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`;
-  console.log("[WWW] render/hooks:createRevalidateCollectionHook collectionSlug=", collectionSlug, "urlPathPrefix=", urlPathPrefix, "sitemapTag=", resolvedSitemapTag, "pathMode=", pathMode);
-  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) => {
-    console.log("[WWW] render/hooks:fireCollectionTags collectionSlug=", collectionSlug, "docId=", docId);
-    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;
-    console.log("[WWW] render/hooks:afterChange collectionSlug=", collectionSlug, "id=", typed.id, "slug=", typed.slug, "prevSlug=", prev?.slug);
-    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:`);
+  return data;
+};
+
+// src/collections/hooks/createRevalidateCollectionGlobalHook.ts
+import { revalidateTag } from "next/cache";
+function createRevalidateCollectionGlobalHook() {
+  const afterChangeDeleteHook = async ({ doc, req, ...args }) => {
+    const previousDoc = "previousDoc" in args ? args.previousDoc : null, locale = req.locale;
+    function revalidate(args2) {
+      try {
+        revalidateTag(createCollectionCacheKey({ ...args2, locale }), "max");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("static generation store missing"))
+          return;
+        console.error(error);
       }
-      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);
+    if ("collection" in args) {
+      [
+        doc && doc._status !== "draft" && doc.slug,
+        previousDoc && previousDoc._status === "published" && previousDoc.slug
+      ].filter((slug) => slug !== undefined && slug !== false).map((slug) => revalidate({ collectionSlug: args.collection.slug, slug }));
+    } else {
+      revalidate({ globalSlug: args.global.slug });
     }
     return doc;
   };
-  const afterDelete = async ({ doc, req }) => {
-    if (shouldSkipRevalidate(req.context))
-      return doc ?? null;
-    const { payload } = req;
-    const typed = doc;
-    console.log("[WWW] render/hooks:afterDelete collectionSlug=", collectionSlug, "id=", typed?.id, "slug=", typed?.slug);
-    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 };
+  return { afterChange: afterChangeDeleteHook, afterDelete: afterChangeDeleteHook };
+}
+function createCollectionCacheKey(args) {
+  return `${"globalSlug" in args ? args.globalSlug : args.collectionSlug + args.slug}_${args.locale}`;
 }
-var createRevalidatePageHooks = (opts = {}) => {
-  console.log("[WWW] render/hooks:createRevalidatePageHooks (deprecated alias) opts=", JSON.stringify(opts));
-  return 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/collections/fields/slug.ts
+var slugField = () => ({
+  name: "slug",
+  type: "text",
+  required: true,
+  unique: true,
+  index: true,
+  localized: true,
+  admin: {
+    position: "sidebar",
+    description: "Lowercase, hyphens for words. Use the `_` divider for nesting, e.g. `about_us` → `/about/us`."
+  },
+  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;
+  }
+});
 
-// 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,
-    nested = false
-  } = options;
-  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({ nested })
-  ];
-  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/collections/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/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 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
-  });
+// src/collections/createWWWCollectionGlobal.ts
+function createWWWCollectionGlobal(fields, {
+  slug: collectionSlug,
+  renderPath,
+  isGlobalConfig = false,
+  isDraft = true
+}) {
   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"
-          }
-        ]
-      },
+    fields: isGlobalConfig ? fields : [
+      slugField(),
       {
         name: "publishedAt",
         type: "date",
         admin: { position: "sidebar" }
-      }
+      },
+      ...fields
     ],
-    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 = {},
-    extraFields = []
-  } = options;
-  console.log("[WWW] core/fields:link options=", JSON.stringify({
-    appearances: appearances === false ? false : appearances ?? "default-set",
-    disableLabel,
-    relationTo,
-    localized,
-    extraFieldsCount: extraFields.length
-  }));
-  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
+    custom: { [name]: { path: renderPath } },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: isDraft ? authenticatedOrPublished : anyone,
+      update: authenticated
     },
-    {
-      name: "url",
-      type: "text",
-      admin: { condition: (_, siblingData) => siblingData?.type === "custom" },
-      label: "Custom URL",
-      required: true,
-      localized
+    hooks: (() => {
+      const { afterChange, afterDelete } = createRevalidateCollectionGlobalHook();
+      return {
+        afterChange: [afterChange],
+        beforeChange: [populatePublishedAt],
+        afterDelete: [afterDelete]
+      };
+    })(),
+    ...isDraft && {
+      versions: { drafts: { autosave: { interval: 3000 } } }
     }
-  ];
-  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
-    });
-  }
-  if (extraFields.length) {
-    result.fields.push(...extraFields);
-  }
-  console.log("[WWW] core/fields:link built fieldsCount=", result.fields.length);
-  return { ...result, ...overrides };
-};
-
-// src/render/hooks/revalidateGlobal.ts
-function createRevalidateGlobalHook(slug) {
-  console.log("[WWW] render/hooks:createRevalidateGlobalHook slug=", slug);
-  return async ({ doc, req: { payload, context, locale } }) => {
-    if (shouldSkipRevalidate(context))
-      return doc;
-    const tags = [`global_${slug}`, `global_${slug}_${locale}`];
-    console.log("[WWW] render/hooks:revalidateGlobal slug=", slug, "locale=", locale, "tags=", JSON.stringify(tags));
-    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],
-    navColumnLinkFields = [],
-    navItemLinkFields = []
-  } = 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, extraFields: navColumnLinkFields })] }
-    ]
-  };
-  const navItemBlock = {
-    slug: "navItem",
-    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo, extraFields: navItemLinkFields })]
-  };
-  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],
-    navColumnLinkFields = [],
-    navItemLinkFields = []
-  } = 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, extraFields: navColumnLinkFields })] }
-    ]
-  };
-  const navItemBlock = {
-    slug: "navItem",
-    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo, extraFields: navItemLinkFields })]
-  };
-  return {
-    slug: "footer",
-    custom: { path: renderPath },
-    access: { read: () => true },
-    fields: [
-      {
-        name: "nav",
-        type: "blocks",
-        required: true,
-        blocks: [navColumnBlock, navItemBlock]
-      }
-    ],
-    hooks: {
-      afterChange: [createRevalidateGlobalHook("footer")]
+// src/render/metadata/query.ts
+import { getPayload } from "payload";
+async function withUnstableCache(keyParts, tags, fn) {
+  const { unstable_cache } = await import("next/cache");
+  return unstable_cache(fn, keyParts.map(String), { tags })();
+}
+async function queryDoc(args, { config: configPromise }) {
+  return withUnstableCache(Object.values(args), [createCollectionCacheKey(args)], async () => {
+    if ("globalSlug" in args)
+      return queryGlobal({ ...args, config: configPromise });
+    else
+      return queryDocBySlug({ ...args, config: configPromise });
+  });
+}
+async function queryDocBySlug({
+  collectionSlug,
+  slug,
+  slugField: slugField2 = "slug",
+  locale,
+  draft = false,
+  config
+}) {
+  return withUnstableCache([collectionSlug, slug, locale, draft], [createCollectionCacheKey({ collectionSlug, slug, locale })], async () => {
+    const payload = await getPayload({ config });
+    const result = await payload.find({
+      collection: collectionSlug,
+      draft,
+      limit: 1,
+      pagination: false,
+      overrideAccess: draft,
+      where: { [slugField2]: { equals: slug } },
+      locale
+    });
+    return result.docs?.[0] ?? null;
+  });
+}
+async function queryGlobal({
+  globalSlug,
+  locale,
+  draft = false,
+  config
+}) {
+  return withUnstableCache([globalSlug, locale, draft], [createCollectionCacheKey({ globalSlug, locale })], async () => {
+    const payload = await getPayload({ config });
+    try {
+      return await payload.findGlobal({ slug: globalSlug, draft, locale });
+    } catch (error) {
+      console.warn("[WWW] queryGlobal failed", { globalSlug, locale, error: String(error) });
+      return null;
     }
-  };
-};
-
-// src/data/collections/previewPath.ts
-var collectionPrefixMap = {
-  posts: "/posts",
-  pages: ""
-};
-function generatePreviewPath({
-  collection,
-  slug
+  });
+}
+async function queryAllDocs({
+  collectionSlug,
+  slugField: slugField2 = "slug",
+  locale,
+  config
+}) {
+  return withUnstableCache([collectionSlug, slugField2, locale], [createCollectionCacheKey({ collectionSlug, slug: "__all__", locale })], async () => {
+    const payload = await getPayload({ config });
+    const result = await payload.find({
+      collection: collectionSlug,
+      draft: false,
+      limit: 1000,
+      pagination: false,
+      overrideAccess: false,
+      select: { [slugField2]: true },
+      locale
+    });
+    return result.docs ?? [];
+  });
+}
+async function queryAllLocaleSlugs({
+  collectionSlug,
+  id,
+  slugField: slugField2 = "slug",
+  config
 }) {
-  if (slug === undefined || slug === null)
-    return null;
-  const encodedSlug = encodeURIComponent(slug);
-  const params = new URLSearchParams({
-    path: `${collectionPrefixMap[collection] ?? ""}/${encodedSlug}`,
-    previewSecret: process.env.PREVIEW_SECRET || ""
+  const payload = await getPayload({ config });
+  const doc = await payload.findByID({
+    collection: collectionSlug,
+    id,
+    locale: "all",
+    select: { [slugField2]: true }
   });
-  return `/next/preview?${params.toString()}`;
+  return doc?.[slugField2];
 }
 
 // src/exports/collections.ts
-var collections_default = {
-  createPagesCollection,
-  createPostsCollection,
-  createStaticPagesCollection,
-  createHeaderGlobal,
-  createFooterGlobal,
-  generatePreviewPath,
-  HOME_PAGE_SLUG,
-  PAGES_SLUG: PAGES_SLUG2,
-  POSTS_SLUG: POSTS_SLUG2,
-  STATIC_PAGES_SLUG
+var collections = {
+  createWWWCollectionGlobal,
+  createRevalidateCollectionGlobalHook,
+  createCollectionCacheKey,
+  queryDoc
 };
+var collections_default = collections;
 export {
-  generatePreviewPath,
+  queryDoc,
   collections_default as default,
-  createStaticPagesCollection,
-  createPostsCollection,
-  createPagesCollection,
-  createHeaderGlobal,
-  createFooterGlobal,
-  STATIC_PAGES_SLUG,
-  POSTS_SLUG2 as POSTS_SLUG,
-  PAGES_SLUG2 as PAGES_SLUG,
-  HOME_PAGE_SLUG
+  createWWWCollectionGlobal,
+  createRevalidateCollectionGlobalHook,
+  createCollectionCacheKey
 };