@justanarthur/payload-www 0.1.1

package/dist/core-access.d.ts

@@ -0,0 +1,11 @@
+import { Access } from "payload";
+declare const anyone: Access;
+declare const authenticated: Access;
+declare const authenticatedOrPublished: Access;
+import { Access as Access_wc6ft0 } from "payload";
+declare const _default: {
+	anyone: Access_wc6ft0;
+	authenticated: Access_wc6ft0;
+	authenticatedOrPublished: Access_wc6ft0;
+};
+export { _default as default, authenticatedOrPublished, authenticated, anyone };

package/dist/core-access.js

@@ -0,0 +1,34 @@
+
+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/exports/core-access.ts
+var core_access_default = { anyone, authenticated, authenticatedOrPublished };
+export {
+  core_access_default as default,
+  authenticatedOrPublished,
+  authenticated,
+  anyone
+};

package/dist/core-blocks.d.ts

@@ -0,0 +1,24 @@
+import { FC } from "react";
+import { ImportMap, SanitizedConfig } from "payload";
+type RenderBlocksProps = {
+	blocks: Array<{
+		blockType: string;
+	} & Record<string, unknown>>;
+	blockProps?: Record<string, unknown>;
+	importMap: ImportMap;
+	config: SanitizedConfig;
+	locale: string;
+	searchParams?: Record<string, string | string[] | undefined>;
+};
+/**
+* Render a page's `blocks` array to React. Each block's render module
+* is resolved via Payload's generated importMap. The host registers
+* each block in the importMap with a key like `BlockCta#default` (use
+* `generateImportName('block', 'cta')` to build the key).
+*
+* Falls back gracefully: if a block's importMap path is missing or
+* the component is not registered, the block is skipped and a
+* `console.warn` is logged (in dev).
+*/
+declare const RenderBlocks: FC<RenderBlocksProps>;
+export { RenderBlocks as default, RenderBlocksProps, RenderBlocks };

package/dist/core-blocks.js

@@ -0,0 +1,75 @@
+
+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) {
+  return importMap[key.includes("#") ? key : key + "#default"];
+}
+
+// src/core/utils/generateImportName.ts
+function generateImportName(type, slug) {
+  switch (type) {
+    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:
+      throw new Error(`Unknown type: ${type}`);
+  }
+}
+
+// src/render/blocks/renderBlocks.tsx
+import { jsx, Fragment } from "react/jsx-runtime";
+var RenderBlocks = ({
+  blocks,
+  blockProps,
+  config,
+  importMap,
+  locale,
+  searchParams
+}) => {
+  if (!blocks || !Array.isArray(blocks) || blocks.length === 0)
+    return null;
+  const rendered = [];
+  for (let i = 0;i < blocks.length; i++) {
+    const block = blocks[i];
+    const { blockType } = block;
+    const importMapPath = config.admin?.dependencies?.[blockType]?.path ?? generateImportName("block", blockType);
+    const Block = getFromImportMap(importMapPath, importMap);
+    if (!Block) {
+      console.warn(`No block found for type: ${blockType}, config.admin?.dependencies?.[blockType]: ${config.admin?.dependencies?.[blockType]}`);
+      continue;
+    }
+    rendered.push(/* @__PURE__ */ jsx(Block, {
+      index: i,
+      ...blockProps,
+      ...block,
+      locale,
+      searchParams
+    }, i));
+  }
+  return /* @__PURE__ */ jsx(Fragment, {
+    children: rendered
+  });
+};
+
+// src/exports/core-blocks.ts
+var core_blocks_default = RenderBlocks;
+export {
+  core_blocks_default as default,
+  RenderBlocks
+};

package/dist/core-fields.d.ts

@@ -0,0 +1,36 @@
+import { Field, GroupField } from "payload";
+type LinkAppearances = "default" | "outline";
+declare const appearanceOptions: Record<LinkAppearances, {
+	label: string;
+	value: string;
+}>;
+type LinkOptions = {
+	appearances?: LinkAppearances[] | false;
+	disableLabel?: boolean;
+	/**
+	* Collection slugs the link can reference. Payload 3.85 rejects
+	* empty arrays, so the lib defaults to `['pages']` (its own Pages
+	* collection). Hosts that reference different collections pass
+	* their own list.
+	*/
+	relationTo?: string[];
+	/** Mark the text fields as `localized: true`. */
+	localized?: boolean;
+	/** Deep-merge into the resulting group. */
+	overrides?: Partial<GroupField>;
+	/** Legacy alias for the host's custom field overrides. */
+	linkOverrides?: Partial<GroupField>;
+};
+declare const link: (options?: LinkOptions) => Field;
+import { Field as Field2 } from "payload";
+declare const linkGroup: (options?: LinkOptions) => Field2;
+import { Field as Field_14espm } from "payload";
+declare const _default: {
+	link: (options?: LinkOptions) => Field_14espm;
+	linkGroup: (options?: LinkOptions) => Field_14espm;
+	appearanceOptions: Record<LinkAppearances, {
+		label: string;
+		value: string;
+	}>;
+};
+export { linkGroup, link, _default as default, appearanceOptions, LinkOptions, LinkAppearances };

package/dist/core-fields.js

@@ -0,0 +1,134 @@
+
+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/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/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/core/fields/linkGroup.ts
+var linkGroup = (options = {}) => ({
+  name: "links",
+  type: "array",
+  fields: [link(options)],
+  admin: { initCollapsed: true }
+});
+
+// src/exports/core-fields.ts
+var core_fields_default = { link, linkGroup, appearanceOptions };
+export {
+  linkGroup,
+  link,
+  core_fields_default as default,
+  appearanceOptions
+};

package/dist/core-utils.d.ts

@@ -0,0 +1,16 @@
+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: {
+	getFromImportMap: typeof getFromImportMap;
+	generateImportName: typeof generateImportName;
+	renderCollectionModule: typeof renderCollectionModule;
+};
+export { renderCollectionModule, getFromImportMap, generateImportName, _default as default };

package/dist/core-utils.js

@@ -0,0 +1,59 @@
+
+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) {
+  return importMap[key.includes("#") ? key : key + "#default"];
+}
+
+// src/core/utils/generateImportName.ts
+function generateImportName(type, slug) {
+  switch (type) {
+    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:
+      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)
+    return null;
+  const CollectionRenderModule = getFromImportMap(renderPath, importMap);
+  if (!CollectionRenderModule) {
+    if (false) {}
+    return null;
+  }
+  return /* @__PURE__ */ jsx(CollectionRenderModule, {
+    importMap,
+    ...props
+  });
+}
+
+// src/exports/core-utils.ts
+var core_utils_default = { getFromImportMap, generateImportName, renderCollectionModule };
+export {
+  renderCollectionModule,
+  getFromImportMap,
+  generateImportName,
+  core_utils_default as default
+};

package/dist/data-collections.d.ts

@@ -0,0 +1,200 @@
+import { Block, CollectionConfig } from "payload";
+type LocalePrefixMode = "always" | "as-needed" | "never";
+type CreateRevalidateCollectionHookOptions = {
+	/**
+	* The collection's slug. Used in the per-collection tag fired
+	* alongside path invalidation: `collection_<slug>_<id>`.
+	*/
+	collectionSlug: string;
+	/**
+	* URL path prefix for this collection's rendered URLs. Pages use
+	* `''` (mounted at root); Posts use `'/posts'`. Leading slash,
+	* no trailing slash — same convention as
+	* `createSitemapFile.urlPrefixes`.
+	*/
+	urlPathPrefix?: string;
+	/**
+	* Sitemap tag the collection's revalidation hook invalidates on
+	* every save. Defaults to `${collectionSlug}-sitemap`. Pass
+	* `false` to opt out (collections without a sitemap handler).
+	*/
+	sitemapTag?: string | false;
+	/**
+	* Locale prefix mode — mirrors next-intl's `localePrefix`.
+	* Defaults to `'always'` (preserves legacy behavior).
+	*/
+	localePrefix?: LocalePrefixMode;
+	/**
+	* Default locale for `localePrefix: 'as-needed'`. Falls back to
+	* `req.payload.config.localization.defaultLocale` at request time
+	* when omitted.
+	*/
+	defaultLocale?: string;
+	/**
+	* Path invalidation strategy. Default: `'url'` — fans out
+	* `revalidatePath` for every locale × every slug. Set to
+	* `'tag-only'` for collections without a URL (e.g. `staticPages`
+	* — addressed by a `kind` discriminator, not a slug). Tag-only
+	* mode still fires the per-collection tag (via `sitemapTag`) and
+	* the per-id tag (`collection_<slug>_<id>`).
+	*/
+	pathMode?: "url" | "tag-only";
+};
+declare const HOME_PAGE_SLUG = "";
+declare const PAGES_SLUG = "pages";
+type CreatePagesCollectionOptions = {
+	/**
+	* Blocks the Pages collection accepts.
+	*/
+	blocks: Block[];
+	/**
+	* Optional override for the collection slug. Default: `'pages'`.
+	* Hosts that want a different slug (e.g. `'site_pages'`) pass
+	* it here. The lib's Header / Footer `linkRelationTo` default
+	* uses `'pages'` — combine this with a matching
+	* `linkRelationTo` to keep nav links targeting the right
+	* collection.
+	*/
+	slug?: string;
+	/**
+	* Optional override for the `custom.path` Payload uses to resolve
+	* the page's render module. Default: the lib's `PAGES_RENDER_PATH`
+	* (a Server Component that calls `RenderBlocks`). Use this when
+	* you've defined your own Server Component for the collection.
+	*/
+	renderPath?: string;
+	/**
+	* Locale prefix mode for path invalidation. Defaults to `'always'`
+	* (preserves current behavior). Set to `'as-needed'` when the host
+	* uses next-intl `localePrefix: 'as-needed'` — otherwise the hook
+	* invalidates paths the public routes don't use.
+	*/
+	localePrefix?: CreateRevalidateCollectionHookOptions["localePrefix"];
+	/**
+	* Default locale for prefix skipping. Falls back to
+	* `req.payload.config.localization.defaultLocale` at request time
+	* when omitted.
+	*/
+	defaultLocale?: CreateRevalidateCollectionHookOptions["defaultLocale"];
+};
+declare const createPagesCollection: (blocks: Block[], options?: Omit<CreatePagesCollectionOptions, "blocks">) => CollectionConfig;
+import { CollectionConfig as CollectionConfig2 } from "payload";
+declare const POSTS_SLUG = "posts";
+type CreatePostsCollectionOptions = {
+	/**
+	* Optional override for the collection slug. Default: `'posts'`.
+	* Hosts that want a different slug (e.g. `'articles'` or `'blog'`)
+	* pass it here. Combine with the page route's URL convention and
+	* the lib's translator plugin's `collections` list.
+	*/
+	slug?: string;
+	/**
+	* Override the `custom.path` Payload uses to resolve the post's
+	* render module. Defaults to the lib's `POSTS_RENDER_PATH`
+	* (the lib's `<PostsPage>` Server Component, which renders
+	* `title` + `excerpt` + Lexical `content`). Hosts that want a
+	* custom render pass their own Server Component's import path
+	* here (e.g. `'@/blog/Post#default'`).
+	*/
+	renderPath?: string;
+	/**
+	* Locale prefix mode for path invalidation. Defaults to `'always'`.
+	* Set to `'as-needed'` when the host uses next-intl
+	* `localePrefix: 'as-needed'` — otherwise the hook invalidates
+	* paths the public routes don't use.
+	*/
+	localePrefix?: "always" | "as-needed" | "never";
+	/**
+	* Default locale for prefix skipping. Falls back to
+	* `req.payload.config.localization.defaultLocale` at request time
+	* when omitted.
+	*/
+	defaultLocale?: string;
+};
+/**
+* Build the Posts collection. Posts have a simpler shape than
+* Pages: `title` + `excerpt` (both localized) + a Lexical `content`
+* rich text field. Hosts that want blocks can either swap the
+* `content` field for a `blocks` field via the returned config, or
+* define a custom Post shape entirely.
+*
+* The Posts collection exists primarily so the lib's translator
+* plugin has a second localized collection to translate.
+*/
+declare const createPostsCollection: (options?: CreatePostsCollectionOptions) => CollectionConfig2;
+import { Block as Block2, CollectionConfig as CollectionConfig3 } from "payload";
+declare const STATIC_PAGES_SLUG = "staticPages";
+type CreateStaticPagesCollectionOptions = {
+	/**
+	* Blocks the StaticPages collection accepts. Hosts pass the same
+	* `blocks` they use for `createPagesCollection` (or a smaller
+	* subset — e.g. just `pageHeroBlock` + `ctaBlock` + `featureGridBlock`).
+	* The lib does not curate a separate block set for system pages.
+	*/
+	blocks: Block2[];
+};
+declare const createStaticPagesCollection: (blocks: Block2[]) => CollectionConfig3;
+import { GlobalConfig } from "payload";
+type CreateHeaderGlobalOptions = {
+	/**
+	* Optional override for the `custom.path` Payload uses to resolve
+	* the header's render module. Default: the lib's `HEADER_RENDER_PATH`.
+	*/
+	renderPath?: string;
+	/**
+	* Collection slugs the nav's link fields can reference. Required
+	* by Payload 3.85 — empty `relationTo` arrays are rejected.
+	* Defaults to `['pages']` (the lib's Pages collection). Pass a
+	* different list when your host has additional linkable collections.
+	*/
+	linkRelationTo?: string[];
+};
+/**
+* Build the Header global. The lib's default shape: a `nav` blocks
+* field with two block types — `navColumn` (a titled group of links)
+* and `navItem` (a single link).
+*/
+declare const createHeaderGlobal: (options?: CreateHeaderGlobalOptions) => GlobalConfig;
+import { GlobalConfig as GlobalConfig2 } from "payload";
+type CreateFooterGlobalOptions = {
+	/**
+	* Optional override for the `custom.path` Payload uses to resolve
+	* the footer's render module. Default: the lib's `FOOTER_RENDER_PATH`.
+	*/
+	renderPath?: string;
+	/**
+	* Collection slugs the nav's link fields can reference. Required
+	* by Payload 3.85 — empty `relationTo` arrays are rejected.
+	* Defaults to `['pages']` (the lib's Pages collection). Pass a
+	* different list when your host has additional linkable collections.
+	*/
+	linkRelationTo?: string[];
+};
+/**
+* Build the Footer global. The lib's default shape mirrors the
+* Header: a `nav` blocks field with `navColumn` (a titled group of
+* links) and `navItem` (a single link) blocks.
+*/
+declare const createFooterGlobal: (options?: CreateFooterGlobalOptions) => GlobalConfig2;
+import { CollectionSlug, PayloadRequest } from "payload";
+declare function generatePreviewPath({ collection, slug }: {
+	collection: CollectionSlug;
+	slug: string | null | undefined;
+	req?: PayloadRequest;
+}): string | null;
+import { Block as Block_129qi5 } from "payload";
+import { CollectionConfig as CollectionConfig_j7kwbk } from "payload";
+import { GlobalConfig as GlobalConfig_fuin17 } from "payload";
+declare const _default: {
+	createPagesCollection: (blocks: Block_129qi5[], options?: Omit<CreatePagesCollectionOptions, "blocks">) => CollectionConfig_j7kwbk;
+	createPostsCollection: (options?: CreatePostsCollectionOptions) => CollectionConfig_j7kwbk;
+	createStaticPagesCollection: (blocks: Block_129qi5[]) => CollectionConfig_j7kwbk;
+	createHeaderGlobal: (options?: CreateHeaderGlobalOptions) => GlobalConfig_fuin17;
+	createFooterGlobal: (options?: CreateFooterGlobalOptions) => GlobalConfig_fuin17;
+	generatePreviewPath: typeof generatePreviewPath;
+	HOME_PAGE_SLUG: string;
+	PAGES_SLUG: string;
+	POSTS_SLUG: string;
+	STATIC_PAGES_SLUG: string;
+};
+export { generatePreviewPath, _default as default, createStaticPagesCollection, createPostsCollection, createPagesCollection, createHeaderGlobal, createFooterGlobal, STATIC_PAGES_SLUG, POSTS_SLUG, PAGES_SLUG, HOME_PAGE_SLUG, CreateStaticPagesCollectionOptions, CreatePostsCollectionOptions, CreatePagesCollectionOptions, CreateHeaderGlobalOptions, CreateFooterGlobalOptions };