@justanarthur/payload-www 0.3.4 → 1.0.1

package/dist/sitemap.d.ts

@@ -0,0 +1,10 @@
+type CreateCollectionPageExportsDeps<S extends string> = {
+	getServerSideURL: () => string;
+	pagePathPrefix?: string;
+};
+type GenerateSitemapPageExportsArgs = CreateCollectionPageExportsDeps<any>;
+declare function createSitemapFromCollections(...args: GenerateSitemapPageExportsArgs[]): () => Response;
+declare const _default: {
+	createSitemapFromCollections: typeof createSitemapFromCollections;
+};
+export { _default as default, createSitemapFromCollections };

package/dist/sitemap.js

@@ -0,0 +1,324 @@
+
+
+// src/render/pages/createCollectionPageExports.tsx
+import"server-only";
+
+// src/render/metadata/slug.ts
+var SLUG_NESTED_DIVIDER = "_";
+function paramsSlugToSlug(slug, _shape) {
+  if (!slug)
+    return "";
+  return (Array.isArray(slug) ? slug : [slug]).join(SLUG_NESTED_DIVIDER);
+}
+function slugToParamsSlug(slug, shape) {
+  if (!slug)
+    return shape === "catch-all" ? [] : "";
+  return shape === "catch-all" ? slug.split(SLUG_NESTED_DIVIDER) : slug;
+}
+
+// src/render/metadata/query.ts
+import { getPayload } from "payload";
+
+// 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);
+      }
+    }
+    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;
+  };
+  return { afterChange: afterChangeDeleteHook, afterDelete: afterChangeDeleteHook };
+}
+function createCollectionCacheKey(args) {
+  return `${"globalSlug" in args ? args.globalSlug : args.collectionSlug + args.slug}_${args.locale}`;
+}
+
+// src/render/metadata/query.ts
+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 = "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: { [slugField]: { 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;
+    }
+  });
+}
+async function queryAllDocs({
+  collectionSlug,
+  slugField = "slug",
+  locale,
+  config
+}) {
+  return withUnstableCache([collectionSlug, slugField, 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: { [slugField]: true },
+      locale
+    });
+    return result.docs ?? [];
+  });
+}
+async function queryAllLocaleSlugs({
+  collectionSlug,
+  id,
+  slugField = "slug",
+  config
+}) {
+  const payload = await getPayload({ config });
+  const doc = await payload.findByID({
+    collection: collectionSlug,
+    id,
+    locale: "all",
+    select: { [slugField]: true }
+  });
+  return doc?.[slugField];
+}
+
+// src/render/pages/createCollectionPageExports.tsx
+import { setRequestLocale } from "next-intl/server";
+
+// src/render/pages/utils/buildLocalizedPath.ts
+function buildLocalizedPath(locale, prefix, slug, { routing }) {
+  return `${routing.localePrefix === "never" ? "" : routing.localePrefix === "always" ? locale : routing.localePrefix === "as-needed" ? locale === routing.defaultLocale ? "" : "/" + locale : (() => {
+    throw new Error("Unsupported locale prefix");
+  })()}${prefix ? "/" + prefix : ""}${slug ? "/" + slug : ""}`;
+}
+function buildLocalizedPaths(localesSlug, pagePathPrefix, { routing }) {
+  return routing.locales.reduce((paths, locale) => {
+    const slug = localesSlug[locale];
+    paths[locale] = buildLocalizedPath(locale, pagePathPrefix, slug, { routing });
+    return paths;
+  }, {});
+}
+function buildAlternates(locale, ...args) {
+  const siteUrl = args[2].siteUrl;
+  let localizedPaths = buildLocalizedPaths(...args);
+  localizedPaths["x-default"] = localizedPaths[args[2].routing.defaultLocale];
+  localizedPaths = Object.fromEntries(Object.entries(localizedPaths).map(([key, value]) => [key, siteUrl + localizedPaths[key]]));
+  return {
+    languages: localizedPaths,
+    canonical: localizedPaths[locale]
+  };
+}
+
+// src/render/pages/createCollectionPageExports.tsx
+import { createSiteDefaults, generateMeta } from "@justanarthur/payload-plugin-seo/next-metadata";
+
+// package.json
+var name = "@justanarthur/payload-www";
+
+// src/render/getFromImportMap.ts
+function getFromImportMap(key, importMap) {
+  return key && importMap[key.includes("#") ? key : key + "#default"];
+}
+
+// src/render/renderWWWModule.tsx
+import { jsx } from "react/jsx-runtime";
+async function renderWWWDataModule(data, {
+  collectionSlug,
+  configPath = "collections",
+  config: configPromise,
+  importMap
+}, props) {
+  const config = await configPromise;
+  const renderPath = config[configPath]?.find((c) => c.slug === collectionSlug)?.custom?.[name]?.path;
+  const RenderModule = getFromImportMap(renderPath, importMap);
+  if (!RenderModule) {
+    if (false) {}
+    return null;
+  }
+  return /* @__PURE__ */ jsx(RenderModule, {
+    data,
+    config,
+    importMap,
+    ...props
+  });
+}
+
+// src/render/pages/createCollectionPageExports.tsx
+import { jsx as jsx2, Fragment } from "react/jsx-runtime";
+function createCollectionPageExports({
+  slug: collectionSlug = "pages",
+  config: configPromise,
+  importMap,
+  routing,
+  slugShape = "single"
+}, {
+  getServerSideURL,
+  pagePathPrefix
+}) {
+  const siteUrl = getServerSideURL();
+  async function fetchDoc(locale, slug) {
+    return queryDoc({
+      slug,
+      locale,
+      collectionSlug
+    }, {
+      config: configPromise
+    });
+  }
+  const default_ = async (props) => {
+    const params = await props.params;
+    const locale = params.locale;
+    if (!routing.locales.includes(locale)) {
+      const { notFound } = await import("next/navigation");
+      return notFound();
+    } else
+      setRequestLocale(locale);
+    const slug = paramsSlugToSlug(params.slug, slugShape);
+    const doc = await fetchDoc(locale, slug);
+    if (!doc) {
+      const { notFound } = await import("next/navigation");
+      notFound();
+    }
+    const rendered = renderWWWDataModule(doc, { collectionSlug, config: configPromise, importMap }, { ...props, locale });
+    return /* @__PURE__ */ jsx2(Fragment, {
+      children: rendered
+    });
+  };
+  async function generateMetadata(props) {
+    const params = await props.params;
+    const locale = params.locale, slug = paramsSlugToSlug(params.slug, slugShape);
+    const doc = await fetchDoc(locale, slug);
+    const [localesSlug, siteDefaults] = await Promise.all([
+      doc ? queryAllLocaleSlugs({
+        id: doc.id,
+        collectionSlug,
+        config: configPromise
+      }) : Promise.resolve({}),
+      createSiteDefaults({ config: configPromise, locale })
+    ]);
+    if (!doc)
+      return {};
+    const alternates = buildAlternates(locale, localesSlug ?? {}, pagePathPrefix, { routing, siteUrl });
+    const meta = await generateMeta({
+      meta: doc.meta,
+      url: alternates.canonical,
+      type: "website",
+      locale,
+      availableLocales: routing.locales,
+      fallback: doc,
+      siteDefaults
+    });
+    console.log("[www#generateMetadata]", { alternates, meta, locale, localesSlug, doc });
+    return { ...meta, alternates };
+  }
+  async function generateStaticParams(props) {
+    const locale = (await props.params).locale;
+    const docs = await queryAllDocs({ locale, collectionSlug, config: configPromise });
+    return docs.filter((doc) => typeof doc.slug === "string" && doc.slug.length > 0).map((doc) => ({ slug: slugToParamsSlug(doc.slug, slugShape) }));
+  }
+  async function generateSitemap() {
+    const locale = routing.defaultLocale;
+    const docs = await queryAllDocs({
+      collectionSlug,
+      locale,
+      config: configPromise
+    });
+    return await Promise.all(docs.map(async (doc) => {
+      const localesSlug = await queryAllLocaleSlugs({
+        id: doc.id,
+        collectionSlug,
+        config: configPromise
+      }) ?? {};
+      const alternates = buildAlternates(locale, localesSlug, pagePathPrefix, { routing, siteUrl });
+      return {
+        url: alternates.canonical,
+        alternates,
+        lastModified: doc.updatedAt || new Date
+      };
+    }));
+  }
+  generateSitemap.getServerSideURL = getServerSideURL;
+  generateSitemap.pagePathPrefix = pagePathPrefix;
+  return {
+    default: default_,
+    generateMetadata,
+    generateStaticParams,
+    generateSitemap
+  };
+}
+function createSitemapFromCollections(...args) {
+  const baseUrl = args[0].getServerSideURL();
+  return function sitemap() {
+    const sitemaps = args.map((arg) => `${baseUrl}/${arg.pagePathPrefix}/sitemap.xml`);
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sitemaps.map((url) => `  <sitemap><loc>${url}</loc></sitemap>`).join(`
+`)}
+</sitemapindex>`;
+    return new Response(xml, {
+      headers: { "Content-Type": "application/xml" }
+    });
+  };
+}
+
+// src/exports/sitemap.ts
+var sitemap_default = { createSitemapFromCollections };
+export {
+  sitemap_default as default,
+  createSitemapFromCollections
+};

package/dist/translator.js

@@ -1,19 +1,4 @@
 
-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/exports/translator.ts
 import { translator } from "@justanarthur/payload-plugin-translator";

package/dist/utils.d.ts

@@ -1,16 +1,8 @@
-import { ImportMap } from "payload";
-declare function getFromImportMap(key: string, importMap: ImportMap): any;
 declare function generateImportName(type: "block" | "page", slug: string): string;
-import { ImportMap as ImportMap2 } from "payload";
-import { JSX as JSX_1kxb } from "react/jsx-runtime";
-type Element_12xgc = JSX_1kxb["Element"];
-declare function renderCollectionModule(collection: {
-	slug: string;
-	custom?: Record<string, any>;
-}[] | undefined, slug: string, importMap: ImportMap2, props?: Record<string, any>): Element_12xgc | null;
-declare const _default: {
+import { ImportMap } from "payload";
+declare function getFromImportMap(key: string | undefined, importMap: ImportMap): any;
+declare const utils: {
 	getFromImportMap: typeof getFromImportMap;
 	generateImportName: typeof generateImportName;
-	renderCollectionModule: typeof renderCollectionModule;
 };
-export { renderCollectionModule, getFromImportMap, generateImportName, _default as default };
+export { getFromImportMap, generateImportName, utils as default };

package/dist/utils.js

@@ -1,72 +1,26 @@
 
-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/utils/getFromImportMap.ts
-function getFromImportMap(key, importMap) {
-  const resolvedKey = key.includes("#") ? key : key + "#default";
-  const value = importMap[resolvedKey];
-  console.log("[WWW] core/utils:getFromImportMap key=", key, "resolved=", resolvedKey, "hit=", Boolean(value));
-  return value;
-}
 
-// src/core/utils/generateImportName.ts
+// src/render/generateImportName.ts
 function generateImportName(type, slug) {
   switch (type) {
-    case "block": {
-      const name = `Block${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
-      console.log("[WWW] core/utils:generateImportName type=block slug=", slug, "->", name);
-      return name;
-    }
-    case "page": {
-      const name = `Page${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
-      console.log("[WWW] core/utils:generateImportName type=page slug=", slug, "->", name);
-      return name;
-    }
+    case "block":
+      return `Block${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
+    case "page":
+      return `Page${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
     default:
-      console.error("[WWW] core/utils:generateImportName unknown type:", type);
       throw new Error(`Unknown type: ${type}`);
   }
 }
 
-// src/render/utils/renderCollectionModule.tsx
-import { jsx } from "react/jsx-runtime";
-function renderCollectionModule(collection = [], slug, importMap, props) {
-  const renderPath = collection?.find((c) => c.slug === slug)?.custom?.path;
-  if (!renderPath) {
-    console.log("[WWW] render/utils:renderCollectionModule no custom.path slug=", slug);
-    return null;
-  }
-  const CollectionRenderModule = getFromImportMap(renderPath, importMap);
-  if (!CollectionRenderModule) {
-    console.error("[WWW] render/utils:renderCollectionModule not found slug=", slug, "path=", renderPath);
-    if (false) {}
-    return null;
-  }
-  console.log("[WWW] render/utils:renderCollectionModule rendering slug=", slug, "path=", renderPath);
-  return /* @__PURE__ */ jsx(CollectionRenderModule, {
-    importMap,
-    ...props
-  });
+// src/render/getFromImportMap.ts
+function getFromImportMap(key, importMap) {
+  return key && importMap[key.includes("#") ? key : key + "#default"];
 }
 
 // src/exports/utils.ts
-var utils_default = { getFromImportMap, generateImportName, renderCollectionModule };
+var utils = { getFromImportMap, generateImportName };
+var utils_default = utils;
 export {
-  renderCollectionModule,
   getFromImportMap,
   generateImportName,
   utils_default as default