@bison-lab/payload-blocks 2.0.0

package/README.md

@@ -0,0 +1,163 @@
+# `@bison-lab/payload-blocks`
+
+Payload CMS block configs and renderers for the Bison Lab marketing blocks.
+
+Install it in a Payload site and editors get the same sections `@bison-lab/ui`
+ships as React props — showcase panels, process steps, FAQ columns, testimonial
+masonry, NAP — as blocks they can add to a page.
+
+```bash
+pnpm add @bison-lab/payload-blocks
+```
+
+Peers: `payload` (required); `react`, `react-dom`, `@bison-lab/ui` and
+`@payloadcms/richtext-lexical` (needed by the renderer entries, optional if you
+only use the configs).
+
+## Two entry points, and why
+
+| Import | Contents | Runs where |
+| --- | --- | --- |
+| `@bison-lab/payload-blocks` | Block configs, field builders, row types, `resolveMedia` | Node. This is what `payload.config.ts` imports, and it touches no React. |
+| `@bison-lab/payload-blocks/react` | Renderers, `RenderBlocks`, the rendering types | Client (`"use client"`). |
+| `@bison-lab/payload-blocks/rich-text` | The `richText` renderer, alone | Client. Split out because it is the only thing that needs `@payloadcms/richtext-lexical`. |
+
+The renderers are client components because the blocks they render are: every
+`@bison-lab/ui` export is a client reference, and these blocks are interactive
+anyway. That is also what makes `imageComponent` work — a Server Component can
+hand a client component reference across the boundary, but not a closure.
+
+## Wiring a site
+
+**1. Add the blocks to a collection.**
+
+```ts
+import {
+  FaqColumnsBlock,
+  HeroBlock,
+  NapBlock,
+  ProcessStepsBlock,
+  RichTextBlock,
+  ShowcasePanelsBlock,
+  TestimonialMasonryBlock,
+} from '@bison-lab/payload-blocks'
+
+export const Pages: CollectionConfig = {
+  slug: 'pages',
+  fields: [
+    { name: 'hero', type: 'blocks', blocks: [HeroBlock], maxRows: 1 },
+    {
+      name: 'layout',
+      type: 'blocks',
+      blocks: [
+        RichTextBlock,
+        ShowcasePanelsBlock,
+        ProcessStepsBlock,
+        FaqColumnsBlock,
+        TestimonialMasonryBlock,
+        NapBlock,
+      ],
+    },
+  ],
+}
+```
+
+Then `payload generate:types` and `payload migrate:create`.
+
+**2. Own the registry.**
+
+The registry is a parameter, not an export, so the compile-time layout lock
+stays in your site — where the generated types are:
+
+```ts
+import type { Page } from '@/payload-types'
+import {
+  type BlockRegistryFor,
+  FaqColumnsBlockRenderer,
+  NapBlockRenderer,
+  ProcessStepsBlockRenderer,
+  ShowcasePanelsBlockRenderer,
+  TestimonialMasonryBlockRenderer,
+} from '@bison-lab/payload-blocks/react'
+import { RichTextBlockRenderer } from '@bison-lab/payload-blocks/rich-text'
+
+type AnyBlock = NonNullable<Page['hero']>[number] | NonNullable<Page['layout']>[number]
+
+export const blockRegistry = {
+  hero: SiteHeroRenderer, // yours; the package's is deliberately plain
+  richText: RichTextBlockRenderer,
+  showcasePanels: ShowcasePanelsBlockRenderer,
+  processSteps: ProcessStepsBlockRenderer,
+  faqColumns: FaqColumnsBlockRenderer,
+  testimonialMasonry: TestimonialMasonryBlockRenderer,
+  nap: NapBlockRenderer,
+} satisfies BlockRegistryFor<AnyBlock>
+```
+
+Add a block to the collection and `satisfies` fails typecheck until it has a
+renderer. Never widen that type to get past the error; add the entry.
+
+**3. Render the page.**
+
+```tsx
+<RenderBlocks
+  blocks={[...page.hero, ...page.layout]}
+  registry={blockRegistry}
+  containerClassName={CONTAINER}
+  imageComponent={NextBlockImage}
+/>
+```
+
+`containerClassName` is your site's page measure. Every renderer puts it on the
+band wrapper and resets the library block's own `max-w-*` / `px-*` so the two
+cannot fight.
+
+`imageComponent` is how images get optimised. The package has no `next`
+dependency — `next/image` needs per-site configuration this package cannot
+supply — so a Next site writes one adapter and passes it once:
+
+```tsx
+'use client'
+import Image from 'next/image'
+import type { BlockImageProps } from '@bison-lab/payload-blocks/react'
+
+export function NextBlockImage({ src, alt, width, height, ...rest }: BlockImageProps) {
+  if (!width || !height) return <Image src={src} alt={alt} fill {...rest} />
+  return <Image src={src} alt={alt} width={width} height={height} {...rest} />
+}
+```
+
+Uploads are served from `/api/media/file/…`, so widen `next.config.ts`
+`images.localPatterns` (or `remotePatterns`) to match before any CMS image
+renders.
+
+## Blocks
+
+| Slug | Renders | Notes |
+| --- | --- | --- |
+| `hero` | plain markup | No `@bison-lab/ui` counterpart. Override this entry with your own. |
+| `richText` | `RichText` (Lexical) | From `/rich-text`. |
+| `showcasePanels` | `ShowcasePanelsBlock` | 3–6 panels, each with a required image. |
+| `processSteps` | `ProcessStepsBlock` | 3–6 ordered steps; advances on a timer. |
+| `faqColumns` | `FAQColumnsBlock` | Answers are plain text, not Lexical — see the config for why. |
+| `testimonialMasonry` | `TestimonialMasonry` | Avatars fall back to initials. |
+| `nap` | `NapBlock` + `JsonLd` | Emits schema.org `LocalBusiness`; `phoneE164` is what the `tel:` link uses. |
+
+A row whose upload has not resolved is dropped rather than rendered empty, and a
+block left with nothing to show renders nothing at all. Draft saves skip Payload
+validation, so live preview genuinely hands renderers incomplete rows.
+
+## Conventions for contributors
+
+- **No generated types.** `src/types.ts` hand-writes each block's row shape to
+  match what Payload generates from the config beside it. Every field is
+  optional and nullable so a site's generated type is assignable to it, and no
+  interface here has an index signature — TypeScript will not assign an
+  interface to a type that does.
+- **`src/index.ts` stays React-free.** Payload loads a site's config outside the
+  bundler, in `migrate`, `generate:types` and the admin server.
+- **`cn()` is off limits.** It is a client-only export of `@bison-lab/ui`; use
+  the local `cx()`.
+- **Changing a field is a schema change in every consuming site.** Update
+  `src/types.ts` and the field-name lock in `src/__tests__/configs.test.ts` in
+  the same change, and say "run `payload migrate:create`" in the changeset.

package/dist/cx-BKHSv3xT.mjs

@@ -0,0 +1,17 @@
+"use client";
+//#region src/cx.ts
+/**
+* Class joining, locally.
+*
+* `cn()` from `@bison-lab/ui` cannot be used here: that barrel is stamped
+* `"use client"`, so calling it from a Server Component throws. The renderers
+* only ever concatenate their own literals with a caller-supplied string —
+* there are no conflicting Tailwind utilities to merge — so a join is enough.
+*/
+function cx(...parts) {
+	return parts.filter(Boolean).join(" ");
+}
+//#endregion
+export { cx as t };
+
+//# sourceMappingURL=cx-BKHSv3xT.mjs.map

package/dist/cx-BKHSv3xT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cx-BKHSv3xT.mjs","names":[],"sources":["../src/cx.ts"],"sourcesContent":["/**\n * Class joining, locally.\n *\n * `cn()` from `@bison-lab/ui` cannot be used here: that barrel is stamped\n * `\"use client\"`, so calling it from a Server Component throws. The renderers\n * only ever concatenate their own literals with a caller-supplied string —\n * there are no conflicting Tailwind utilities to merge — so a join is enough.\n */\nexport function cx(...parts: (string | false | null | undefined)[]): string {\n  return parts.filter(Boolean).join(\" \");\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgB,GAAG,GAAG,OAAsD;AAC1E,QAAO,MAAM,OAAO,QAAQ,CAAC,KAAK,IAAI"}

package/dist/index.d.mts

@@ -0,0 +1,344 @@
+import { Block, CollectionSlug, Field, GroupField, UploadField } from "payload";
+
+//#region src/blocks/hero/config.d.ts
+/**
+ * The band a page opens with.
+ *
+ * Unlike every other block here this one has no `@bison-lab/ui` counterpart:
+ * a hero is where a site's brand is loudest, and the shipped renderer is
+ * deliberately plain markup so a site can swap in its own by overriding this
+ * one registry entry. The *fields* are the shared part — that is what makes a
+ * page portable between sites.
+ */
+declare const HeroBlock: Block;
+//#endregion
+//#region src/blocks/rich-text/config.d.ts
+/** A prose section: one Lexical document at reading measure. */
+declare const RichTextBlock: Block;
+//#endregion
+//#region src/blocks/showcase-panels/config.d.ts
+/** Expanding panels, one per service or product line. */
+declare const ShowcasePanelsBlock: Block;
+//#endregion
+//#region src/blocks/process-steps/config.d.ts
+/** An ordered walkthrough that advances on its own. */
+declare const ProcessStepsBlock: Block;
+//#endregion
+//#region src/blocks/faq-columns/config.d.ts
+/** A sticky intro beside a column of questions. */
+declare const FaqColumnsBlock: Block;
+//#endregion
+//#region src/blocks/testimonial-masonry/config.d.ts
+/** Quotes in a masonry grid, clipped behind a fade once there are enough. */
+declare const TestimonialMasonryBlock: Block;
+//#endregion
+//#region src/blocks/nap/config.d.ts
+/**
+ * Name, address, phone — the block local SEO is graded on.
+ *
+ * The `e164` phone number is a separate field from the displayed one because
+ * `NapBlock` uses it, and only it, for the `tel:` href and the JSON-LD
+ * `telephone`. A prettified string can never silently become an unreachable
+ * link.
+ */
+declare const NapBlock: Block;
+//#endregion
+//#region src/fields/image.d.ts
+/**
+ * Payload's `UploadField` is a union over the polymorphic (`relationTo: [...]`)
+ * and `hasMany` variants. A block image is neither, and narrowing here is what
+ * lets `imageField({ name: 'portrait' })` stay type-checked at the call site.
+ */
+type MediaUploadField = Extract<UploadField, {
+  hasMany?: false;
+  relationTo: CollectionSlug;
+}>;
+interface ImageFieldOptions extends Partial<MediaUploadField> {
+  /**
+   * The upload collection to point at. Every Bison Lab site names it `media`,
+   * but a site that does not can say so without forking the field.
+   */
+  relationTo?: CollectionSlug;
+}
+/**
+ * A single image from the site's upload collection, for any block with a
+ * picture in it.
+ *
+ * Optional unless the block says otherwise: `imageField({ name: 'portrait',
+ * required: true })`. `admin` is replaced, not merged, so a block that passes
+ * its own description writes the whole thing.
+ */
+declare function imageField(overrides?: ImageFieldOptions): MediaUploadField;
+//#endregion
+//#region src/fields/link.d.ts
+interface LinkFieldsOptions {
+  /** Require the label and destination. Defaults to `false`. */
+  required?: boolean;
+  /** Wording for the visible text field. Defaults to "Label". */
+  labelFieldLabel?: string;
+}
+/**
+ * The three fields a call to action is made of, unwrapped.
+ *
+ * `href` is plain text rather than a relationship to a `pages` row: a block in
+ * this package has to work on a site whose page collection is named something
+ * else, or which links out more often than in. Resolving an internal reference
+ * is the site's job.
+ *
+ * `newTab` drives `target="_blank"` *and* the matching `rel`, which is why no
+ * renderer takes one without the other.
+ */
+declare function linkFields({
+  required,
+  labelFieldLabel
+}?: LinkFieldsOptions): Field[];
+interface LinkFieldOptions extends LinkFieldsOptions {
+  /** Field name. Defaults to `link`. */
+  name?: string;
+  label?: GroupField["label"];
+  admin?: GroupField["admin"];
+}
+/** `linkFields()` as one named group, for a block with a single CTA. */
+declare function linkField({
+  name,
+  label,
+  admin,
+  ...rest
+}?: LinkFieldOptions): GroupField;
+/** The shape `linkField`/`linkFields` produce once Payload generates types. */
+interface LinkValue {
+  label?: string | null;
+  href?: string | null;
+  newTab?: boolean | null;
+}
+//#endregion
+//#region src/fields/heading.d.ts
+interface HeadingFieldsOptions {
+  /** Require the section heading. Defaults to `true`. */
+  required?: boolean;
+  /** Description shown under the eyebrow input. */
+  eyebrowDescription?: string;
+}
+/**
+ * The eyebrow / title / description trio every marketing band opens with.
+ *
+ * They are three top-level fields rather than a group: editors read a section
+ * heading as the first thing in the block, and burying it one collapse deep
+ * puts the least-optional copy behind a click. The field names match the
+ * `@bison-lab/ui` prop names so the renderers stay a pass-through.
+ */
+declare function headingFields({
+  required,
+  eyebrowDescription
+}?: HeadingFieldsOptions): Field[];
+//#endregion
+//#region src/media.d.ts
+/**
+ * The upload side of the boundary.
+ *
+ * A Payload upload field holds either the row's id or, once depth resolves it,
+ * the whole document. Neither shape can be imported from here: `Media` is
+ * generated per site, and this package must never reach for a site's
+ * `payload-types`. So the doc is described structurally, and every renderer
+ * goes through `resolveMedia` rather than reading `.url` itself.
+ */
+/**
+ * The subset of a Payload upload document a block renderer actually reads.
+ * Every site's generated `Media` interface is assignable to this, whatever
+ * else it carries.
+ *
+ * Deliberately no index signature: TypeScript refuses to assign an interface
+ * to a type with one, and a site's generated `Media` is always an interface.
+ * An index signature here would break exactly the structural match this type
+ * exists to provide.
+ */
+interface MediaDoc {
+  url?: string | null;
+  alt?: string | null;
+  width?: number | null;
+  height?: number | null;
+}
+/** What an upload field holds before and after `depth` populates it. */
+type MediaValue = number | string | MediaDoc | null | undefined;
+/** A resolved image, in the shape every `@bison-lab/ui` block asks for. */
+interface ResolvedMedia {
+  src: string;
+  alt: string;
+  width?: number;
+  height?: number;
+}
+/**
+ * Narrows an upload value to something renderable, or `undefined`.
+ *
+ * `undefined` covers three cases a renderer must treat identically: the field
+ * is empty, `depth: 0` left it as a bare id, or the document exists but has no
+ * `url` yet (an upload mid-flight). A renderer that gets `undefined` omits the
+ * image rather than emitting a broken `<img>`.
+ *
+ * `alt` is always a string: the media collection requires it, but a draft saved
+ * before that validation ran can still reach a renderer, and an `alt` of
+ * `undefined` would silently drop the attribute entirely.
+ */
+declare function resolveMedia(value: MediaValue): ResolvedMedia | undefined;
+//#endregion
+//#region src/types.d.ts
+/**
+ * The data shape of every block in this package, hand-written.
+ *
+ * A package cannot import a site's `payload-types`: those are generated per
+ * site, from that site's own config. So each block's row shape is written out
+ * here to match what Payload generates from the config next to it, and a
+ * site's generated types then match *structurally* — no import, no adapter.
+ *
+ * Two conventions make that match reliable:
+ *
+ * 1. **Everything is optional and nullable**, `blockType` aside. A generated
+ *    `title: string` is assignable to `title?: string | null`, never the other
+ *    way round, so the permissive direction is the only safe one. It is also
+ *    the honest one: Payload skips validation on draft saves, so a live-preview
+ *    render genuinely can receive a row with its required fields still empty.
+ *    Renderers guard rather than assume.
+ * 2. **No index signatures.** TypeScript will not assign an interface to a type
+ *    that has one, and a generated block type is always an interface.
+ *
+ * The field-name lists in `src/__tests__/configs.test.ts` are the lock between
+ * a config and its interface here: rename a field and that test fails.
+ */
+/** The tail Payload appends to every block row. */
+interface BlockRow<T extends string> {
+  id?: string | null;
+  blockName?: string | null;
+  blockType: T;
+}
+/**
+ * A Lexical document, structurally. The generated type carries an index
+ * signature and a narrower `format` union; both are assignable to this.
+ */
+interface RichTextContent {
+  root: {
+    type: string;
+    children: unknown[];
+    direction: ("ltr" | "rtl") | null;
+    format: string;
+    indent: number;
+    version: number;
+  };
+}
+interface HeroBlockData extends BlockRow<"hero"> {
+  eyebrow?: string | null;
+  heading?: string | null;
+  body?: string | null;
+  tone?: ("sweep" | "dark" | "light") | null;
+  image?: MediaValue;
+  links?: LinkValue[] | null;
+}
+interface RichTextBlockData extends BlockRow<"richText"> {
+  content?: RichTextContent | null;
+}
+interface ShowcasePanelsItemData {
+  title?: string | null;
+  summary?: string | null;
+  image?: MediaValue;
+  href?: string | null;
+  numeral?: string | null;
+  id?: string | null;
+}
+interface ShowcasePanelsBlockData extends BlockRow<"showcasePanels"> {
+  items?: ShowcasePanelsItemData[] | null;
+  watermark?: string | null;
+  spineVariant?: ("numbered" | "volume" | "minimal") | null;
+  defaultActiveIndex?: number | null;
+  ariaLabel?: string | null;
+  labels?: {
+    selected?: string | null;
+    preview?: string | null;
+  };
+}
+interface ProcessStepsItemData {
+  title?: string | null;
+  description?: string | null;
+  image?: MediaValue;
+  step?: number | null;
+  id?: string | null;
+}
+interface ProcessStepsBlockData extends BlockRow<"processSteps"> {
+  items?: ProcessStepsItemData[] | null;
+  defaultActiveIndex?: number | null;
+  autoAdvance?: boolean | null;
+  autoAdvanceDuration?: number | null;
+  pauseOnHover?: boolean | null;
+  ariaLabel?: string | null;
+  labels?: {
+    pause?: string | null;
+    resume?: string | null;
+  };
+}
+interface FaqColumnsItemData {
+  question?: string | null;
+  /** A textarea, not a Lexical document — see the block's config for why. */
+  answer?: string | null;
+  id?: string | null;
+}
+interface FaqColumnsBlockData extends BlockRow<"faqColumns"> {
+  eyebrow?: string | null;
+  title?: string | null;
+  description?: string | null;
+  items?: FaqColumnsItemData[] | null;
+  cta?: {
+    title?: string | null;
+    linkText?: string | null;
+    href?: string | null;
+    newTab?: boolean | null;
+  };
+  sticky?: boolean | null;
+  type?: ("single" | "multiple") | null;
+  collapsible?: boolean | null;
+}
+interface TestimonialMasonryItemData {
+  content?: string | null;
+  author?: {
+    name?: string | null;
+    title?: string | null;
+    avatar?: MediaValue;
+  };
+  id?: string | null;
+}
+interface TestimonialMasonryBlockData extends BlockRow<"testimonialMasonry"> {
+  eyebrow?: string | null;
+  title?: string | null;
+  description?: string | null;
+  items?: TestimonialMasonryItemData[] | null;
+  link?: LinkValue;
+  minItemsForFade?: number | null;
+  maxVisibleRows?: number | null;
+}
+interface NapDepartmentData {
+  name?: string | null;
+  departmentType?: string | null;
+  phoneE164?: string | null;
+  phoneDisplay?: string | null;
+  id?: string | null;
+}
+interface NapBlockData extends BlockRow<"nap"> {
+  businessName?: string | null;
+  businessType?: string | null;
+  address?: {
+    streetAddress?: string | null;
+    addressLocality?: string | null;
+    addressRegion?: string | null;
+    postalCode?: string | null;
+    addressCountry?: string | null;
+  };
+  departments?: NapDepartmentData[] | null;
+  url?: string | null;
+  showName?: boolean | null;
+  headingLevel?: ("h2" | "h3" | "h4") | null;
+  emitJsonLd?: boolean | null;
+}
+/** Every block this package ships, as one union. */
+type BisonBlockData = HeroBlockData | RichTextBlockData | ShowcasePanelsBlockData | ProcessStepsBlockData | FaqColumnsBlockData | TestimonialMasonryBlockData | NapBlockData;
+/** The `blockType` of every block this package ships. */
+type BisonBlockType = BisonBlockData["blockType"];
+//#endregion
+export { type BisonBlockData, type BisonBlockType, FaqColumnsBlock, type FaqColumnsBlockData, type FaqColumnsItemData, type HeadingFieldsOptions, HeroBlock, type HeroBlockData, type ImageFieldOptions, type LinkFieldOptions, type LinkFieldsOptions, type LinkValue, type MediaDoc, type MediaValue, NapBlock, type NapBlockData, type NapDepartmentData, ProcessStepsBlock, type ProcessStepsBlockData, type ProcessStepsItemData, type ResolvedMedia, RichTextBlock, type RichTextBlockData, type RichTextContent, ShowcasePanelsBlock, type ShowcasePanelsBlockData, type ShowcasePanelsItemData, TestimonialMasonryBlock, type TestimonialMasonryBlockData, type TestimonialMasonryItemData, headingFields, imageField, linkField, linkFields, resolveMedia };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/blocks/hero/config.ts","../src/blocks/rich-text/config.ts","../src/blocks/showcase-panels/config.ts","../src/blocks/process-steps/config.ts","../src/blocks/faq-columns/config.ts","../src/blocks/testimonial-masonry/config.ts","../src/blocks/nap/config.ts","../src/fields/image.ts","../src/fields/link.ts","../src/fields/heading.ts","../src/media.ts","../src/types.ts"],"mappings":"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"}