bsmnt 0.11.0 → 0.13.0

package/src/modules/features/consent/ketch/files/lib/integrations/ketch/preferences-button.tsx

@@ -0,0 +1,51 @@
+"use client"
+
+import { cva, type VariantProps } from "class-variance-authority"
+import type { ComponentPropsWithoutRef } from "react"
+import { isKetchConfigured } from "@/lib/integrations/check-integration"
+import { cn } from "@/lib/styles/cn"
+import { useConsent } from "./use-consent"
+
+const preferencesButton = cva("w-fit text-left transition-colors", {
+  variants: {
+    variant: {
+      footer: "text-secondary/60 hover:text-secondary",
+      strong: "text-secondary hover:text-secondary/60",
+      link: "text-secondary underline underline-offset-4 hover:no-underline",
+    },
+    size: {
+      sm: "text-sm",
+      md: "text-base",
+    },
+  },
+  defaultVariants: {
+    variant: "footer",
+    size: "md",
+  },
+})
+
+type ConsentPreferencesButtonProps = ComponentPropsWithoutRef<"button"> &
+  VariantProps<typeof preferencesButton>
+
+export const ConsentPreferencesButton = ({
+  className,
+  variant,
+  size,
+  children,
+  ...props
+}: ConsentPreferencesButtonProps) => {
+  const { openPreferences } = useConsent()
+
+  if (!isKetchConfigured()) return null
+
+  return (
+    <button
+      type="button"
+      onClick={openPreferences}
+      className={cn(preferencesButton({ variant, size }), className)}
+      {...props}
+    >
+      {children ?? "Privacy Choices"}
+    </button>
+  )
+}

package/src/modules/features/consent/ketch/files/lib/integrations/ketch/script.tsx

@@ -0,0 +1,8 @@
+import { ketchBootUrl } from "./env"
+import "./ketch-experience.css"
+
+export const KetchConsentScript = () => {
+  if (!ketchBootUrl) return null
+
+  return <script async src={ketchBootUrl} />
+}

package/src/modules/features/consent/ketch/files/lib/integrations/ketch/types.ts

@@ -0,0 +1,15 @@
+export type KetchPurposeValue = boolean | "true" | "false" | undefined
+
+export type KetchConsent = {
+  purposes?: Record<string, KetchPurposeValue>
+  vendors?: string[]
+}
+
+export type KetchJurisdictionEvent = string | { code?: string } | undefined
+
+export type KetchSemaphore = unknown[] & { loaded?: boolean }
+
+export type KetchWindow = Window & {
+  ketch?: (...command: unknown[]) => void
+  semaphore?: KetchSemaphore
+}

package/src/modules/features/consent/ketch/files/lib/integrations/ketch/use-consent.ts

@@ -0,0 +1,26 @@
+"use client"
+
+import { useCallback, useSyncExternalStore } from "react"
+import type { ConsentCategory } from "./categories"
+import { consentStore } from "./consent-store"
+
+export const useConsent = () => {
+  const { isResolved, jurisdiction, granted } = useSyncExternalStore(
+    consentStore.subscribe,
+    consentStore.getSnapshot,
+    consentStore.getServerSnapshot
+  )
+
+  const hasConsent = useCallback(
+    (category: ConsentCategory) => granted[category],
+    [granted]
+  )
+
+  return {
+    hasConsent,
+    granted,
+    isResolved,
+    jurisdiction,
+    openPreferences: consentStore.openPreferences,
+  }
+}

package/src/modules/features/jobs/ashby/files/_sanity-adapter/job-board-block.ts

@@ -0,0 +1,53 @@
+import { CaseIcon } from "@sanity/icons"
+import { defineField, defineType } from "sanity"
+
+export const ashbyJobBoardBlock = defineType({
+  name: "ashbyJobBoardBlock",
+  title: "Ashby Job Board",
+  type: "document",
+  icon: CaseIcon,
+  description:
+    "Lists open roles pulled live from Ashby. There is no content to manage here beyond an optional heading.",
+  fields: [
+    defineField({
+      name: "internalTitle",
+      title: "Internal Title",
+      type: "string",
+      description: "Only used to identify this block in the Studio.",
+      validation: (Rule) => Rule.required(),
+    }),
+    defineField({
+      name: "heading",
+      title: "Heading",
+      type: "string",
+      description: "Optional heading shown above the list of positions.",
+    }),
+    defineField({
+      name: "boardName",
+      title: "Job Board Name",
+      type: "string",
+      description:
+        "Optional. Overrides the ASHBY_JOB_BOARD_NAME environment variable — the board's slug in its jobs.ashbyhq.com URL.",
+    }),
+  ],
+  preview: {
+    select: {
+      title: "internalTitle",
+      heading: "heading",
+      boardName: "boardName",
+    },
+    prepare({ title, heading, boardName }) {
+      return {
+        title: title || "Ashby Job Board",
+        subtitle: heading || boardName || "Open positions",
+      }
+    },
+  },
+})
+
+export const ashbyJobBoardBlockReference = defineType({
+  name: "ashbyJobBoardBlockReference",
+  title: "Ashby Job Board",
+  type: "reference",
+  to: [{ type: "ashbyJobBoardBlock" }],
+})

package/src/modules/features/jobs/ashby/files/lib/integrations/ashby/README.md

@@ -0,0 +1,134 @@
+# Ashby job board integration
+
+Agnostic, reusable [Ashby](https://www.ashbyhq.com/) job-board reader. The core
+(`index.ts`, `normalize.ts`, `types.ts`) has **no CMS dependency** and adds **no
+runtime packages** — it reads Ashby's public Job Posting API and normalizes it
+into a stable `CareerJob[]`.
+
+Fetching is **server-only**: `getCareerJobs` uses `react`'s `cache` and Next.js
+`fetch` revalidation, so call it from a Server Component, Route Handler, or
+`generateMetadata` — never from a `"use client"` component.
+
+## 1. Environment
+
+Ashby's job-board endpoint is public — no token or private app required. The
+only configuration is the board name, which is the slug in your board's URL
+(`https://jobs.ashbyhq.com/<board-name>`):
+
+```bash
+ASHBY_JOB_BOARD_NAME=your-board
+```
+
+The value is not a secret, so it can stay plaintext in the committed env file.
+It is only read server-side (in `env.ts`); it is never exposed to the client.
+You can also skip the variable entirely and pass the board name explicitly.
+
+`env.ts` resolves it once at module scope as `ashbyBoardName`, and
+`isAshbyConfigured()` in `lib/integrations/check-integration.ts` derives from
+that same value — so a "configured" check can never disagree with what
+`getCareerJobs` actually resolves.
+
+## 2. Read the jobs
+
+```tsx
+import { getCareerJobs } from "@/lib/integrations/ashby"
+
+export default async function Careers() {
+  const jobs = await getCareerJobs()
+
+  return (
+    <ul>
+      {jobs.map((job) => (
+        <li key={job.id}>
+          <a href={job.href}>{job.title}</a>
+        </li>
+      ))}
+    </ul>
+  )
+}
+```
+
+Pass a board name to override `ASHBY_JOB_BOARD_NAME` (useful for multi-brand
+sites, or to render a second board on one page):
+
+```tsx
+const jobs = await getCareerJobs("your-other-board")
+```
+
+`getCareerJobs` throws when the board name is missing or when Ashby responds
+with a non-2xx status. Wrap the call so a job-board outage degrades gracefully
+instead of failing the whole page:
+
+```tsx
+let jobs: CareerJob[] = []
+try {
+  jobs = await getCareerJobs()
+} catch (error) {
+  console.error("Failed to load Ashby jobs", error)
+}
+```
+
+## 3. What you get
+
+`normalize.ts` tolerates both the current (`jobs`) and legacy (`jobPostings`)
+payload shapes, drops unlisted postings, and resolves each field from the
+several key spellings Ashby has used over time. Every optional field is
+`string | null` — never `undefined` — so rendering stays branch-free:
+
+| Field | Notes |
+| --- | --- |
+| `id` / `title` / `href` | Required; a posting missing any of them is dropped |
+| `applyUrl` | Direct application link when Ashby exposes one |
+| `location` / `department` / `team` | Resolved from the flat or nested variants |
+| `employmentType` | e.g. `Full-time` |
+| `workType` | `workplaceType`, or derived from `isRemote` |
+| `isRemote` | `true` only when Ashby says so explicitly |
+| `publishedAt` | ISO date string |
+| `descriptionHtml` | Raw HTML — sanitize before injecting |
+| `compensation` | `{ summary, display }`; respect `display` before rendering |
+
+## 4. Caching
+
+The core caches the board for 5 minutes via `next: { revalidate: 300 }`, and
+deduplicates calls within a single request via React `cache`.
+
+In a **Cache Components** project (`cacheComponents: true`), the fetch-level
+revalidate is ignored — wrap the call in your own cached function instead:
+
+```tsx
+import { cacheLife } from "next/cache"
+import { getCareerJobs } from "@/lib/integrations/ashby"
+
+async function getCachedJobs() {
+  "use cache"
+  cacheLife("minutes")
+  return getCareerJobs()
+}
+```
+
+## 5. Optional: Sanity Studio block
+
+When this integration is added to a project that already has Sanity, a
+`sanity/` folder ships alongside the core:
+
+- `sanity/job-board-block.ts` — an `ashbyJobBoardBlock` document type with an
+  optional `heading` and an optional per-block `boardName` override
+
+Register it by adding `ashbyJobBoardBlock` to your schema's document list, then
+render it from your own component.
+
+## 6. Use as a page-builder block
+
+In a basement **Sanity page-builder** project, `ashbyJobBoardBlock` can be a
+selectable block. Adding this integration installs the
+**`ashby-pagebuilder-block`** agent skill — ask your coding agent to "wire the
+Ashby job board into the page builder" and it makes the edits and verifies the
+typecheck. To do it by hand:
+
+1. `schemas/index.ts` — import `ashbyJobBoardBlock`, add it to `schema.types`
+2. `page-builder-config.ts` — add `"ashbyJobBoardBlock"` to
+   `PageBuilderDocumentType` and an `ashbyJobBoardBlockReference` member
+3. `structure.ts` — add `S.documentTypeListItem("ashbyJobBoardBlock")`
+4. `components/page-builder/renderer.tsx` — add a `case "ashbyJobBoardBlock"`
+   that awaits `getCareerJobs(block.boardName)` and renders the list
+5. `bun run sanity:typegen && bun typecheck`

package/src/modules/features/jobs/ashby/files/lib/integrations/ashby/env.ts

@@ -0,0 +1,3 @@
+const readBoardName = (value: string | undefined) => value?.trim() ?? ""
+
+export const ashbyBoardName = readBoardName(process.env.ASHBY_JOB_BOARD_NAME)

package/src/modules/features/jobs/ashby/files/lib/integrations/ashby/index.ts

@@ -0,0 +1,40 @@
+import { cache } from "react"
+import { ashbyBoardName } from "./env"
+import { normalizeBoard } from "./normalize"
+import type { CareerJob } from "./types"
+
+const ASHBY_JOB_BOARD_API_URL = "https://api.ashbyhq.com/posting-api/job-board"
+const BOARD_REVALIDATE_SECONDS = 300
+
+export function resolveAshbyBoardName(boardName?: string | null): string {
+  const resolved = boardName?.trim() || ashbyBoardName
+
+  if (!resolved) {
+    throw new Error(
+      "Missing Ashby job board name. Pass it to getCareerJobs() or set ASHBY_JOB_BOARD_NAME."
+    )
+  }
+
+  return resolved
+}
+
+export const getCareerJobs = cache(
+  async (boardName?: string | null): Promise<CareerJob[]> => {
+    const board = resolveAshbyBoardName(boardName)
+
+    const response = await fetch(
+      `${ASHBY_JOB_BOARD_API_URL}/${encodeURIComponent(board)}?includeCompensation=true`,
+      { next: { revalidate: BOARD_REVALIDATE_SECONDS } }
+    )
+
+    if (!response.ok) {
+      throw new Error(`Ashby request failed with ${response.status}`)
+    }
+
+    return normalizeBoard(await response.json(), board)
+  }
+)
+
+export { ashbyBoardName } from "./env"
+export { normalizeBoard } from "./normalize"
+export type { CareerCompensation, CareerJob } from "./types"

package/src/modules/features/jobs/ashby/files/lib/integrations/ashby/normalize.ts

@@ -0,0 +1,124 @@
+import type { CareerCompensation, CareerJob } from "./types"
+
+const toRecord = (value: unknown): Record<string, unknown> | null =>
+  value && typeof value === "object" ? (value as Record<string, unknown>) : null
+
+const string = (value: unknown): string | null =>
+  typeof value === "string" && value.trim() ? value.trim() : null
+
+const getFieldValue = (
+  job: Record<string, unknown>,
+  key: string
+): string | null => {
+  const value = job[key]
+  if (typeof value === "string") return string(value)
+
+  const nested = toRecord(value)
+  if (!nested) return null
+
+  return string(nested.name) ?? string(nested.title) ?? string(nested.value)
+}
+
+const idFromUrl = (url: string | null): string | null => {
+  if (!url) return null
+
+  try {
+    const parsed = new URL(url)
+    const fromQuery = string(parsed.searchParams.get("ashby_jid"))
+    if (fromQuery) return fromQuery
+
+    const segments = parsed.pathname.split("/").filter(Boolean)
+    const last = segments.at(-1)
+    if (last === "application") return string(segments.at(-2))
+    return string(last)
+  } catch {
+    return null
+  }
+}
+
+const getCompensation = (
+  job: Record<string, unknown>
+): CareerCompensation | null => {
+  const compensation = toRecord(job.compensation)
+  if (!compensation) return null
+
+  const summary =
+    string(compensation.compensationTierSummary) ??
+    string(compensation.scrapeableCompensationSalarySummary)
+  if (!summary) return null
+
+  return {
+    summary,
+    display: job.shouldDisplayCompensationOnJobPostings !== false,
+  }
+}
+
+const getWorkType = (job: Record<string, unknown>): string | null => {
+  const workplaceType = getFieldValue(job, "workplaceType")
+  if (workplaceType) return workplaceType
+  if (job.isRemote === true) return "Remote"
+  return job.isRemote === false ? "On-site" : null
+}
+
+const toCareerJob = (value: unknown, boardName: string): CareerJob | null => {
+  const job = toRecord(value)
+  if (!job) return null
+
+  if (job.isListed === false) return null
+
+  const jobUrl = string(job.jobUrl)
+  const applyUrl = string(job.applyUrl)
+
+  const id =
+    string(job.id) ??
+    string(job.jobId) ??
+    string(job.jobPostingId) ??
+    string(job.ashbyJid) ??
+    idFromUrl(jobUrl) ??
+    idFromUrl(applyUrl)
+
+  const title = getFieldValue(job, "title")
+  const href =
+    jobUrl ??
+    applyUrl ??
+    (id
+      ? `https://jobs.ashbyhq.com/${encodeURIComponent(boardName)}/${id}`
+      : null)
+
+  if (!(id && title && href)) return null
+
+  return {
+    id,
+    title,
+    href,
+    applyUrl,
+    location:
+      getFieldValue(job, "location") ?? getFieldValue(job, "locationName"),
+    department:
+      getFieldValue(job, "department") ?? getFieldValue(job, "departmentName"),
+    team: getFieldValue(job, "team") ?? getFieldValue(job, "teamName"),
+    employmentType:
+      getFieldValue(job, "employmentType") ?? getFieldValue(job, "jobType"),
+    workType: getWorkType(job),
+    publishedAt: string(job.publishedAt) ?? string(job.publishedDate) ?? null,
+    isRemote: job.isRemote === true,
+    descriptionHtml: string(job.descriptionHtml),
+    compensation: getCompensation(job),
+  }
+}
+
+export const normalizeBoard = (
+  payload: unknown,
+  boardName: string
+): CareerJob[] => {
+  const board = toRecord(payload)
+  if (!board) return []
+
+  const jobs = Array.isArray(board.jobs) ? board.jobs : null
+  const legacy = Array.isArray(board.jobPostings) ? board.jobPostings : null
+  const raw = jobs ?? legacy ?? []
+
+  return raw
+    .map((job) => toCareerJob(job, boardName))
+    .filter((job): job is CareerJob => job !== null)
+}

package/src/modules/features/jobs/ashby/files/lib/integrations/ashby/types.ts

@@ -0,0 +1,20 @@
+export type CareerCompensation = {
+  summary: string
+  display: boolean
+}
+
+export type CareerJob = {
+  id: string
+  title: string
+  href: string
+  applyUrl: string | null
+  location: string | null
+  department: string | null
+  team: string | null
+  employmentType: string | null
+  workType: string | null
+  publishedAt: string | null
+  isRemote: boolean
+  descriptionHtml: string | null
+  compensation: CareerCompensation | null
+}

package/src/modules/features/jobs/ashby/files/lib/integrations/check-integration.ts

@@ -0,0 +1,25 @@
+import { ashbyBoardName } from "@/lib/integrations/ashby/env"
+
+/**
+ * Integration Configuration Checker
+ *
+ * Utilities to check if integrations are configured via environment variables.
+ * This helps with tree-shaking unused integrations from the bundle.
+ *
+ * Usage:
+ * ```ts
+ * import { isAshbyConfigured } from '@/integrations/check-integration'
+ *
+ * if (isAshbyConfigured()) {
+ *   // Only fetch the job board once a board name is set
+ * }
+ * ```
+ */
+
+/**
+ * Check if the Ashby job board is configured. Derived from env.ts, not a
+ * second read of `process.env`.
+ */
+export function isAshbyConfigured(): boolean {
+  return Boolean(ashbyBoardName)
+}

package/src/templates/next-default/.biome/plugins/no-fill-without-sizes.grit

@@ -0,0 +1,11 @@
+language js
+
+or {
+	`<Image $attrs />`,
+	`<SanityImage $attrs />`
+} as $image where {
+	$attrs <: contains `fill`,
+	! $attrs <: contains `fill={false}`,
+	! $attrs <: contains or { `sizes`, `mobileSize`, `desktopSize` },
+	register_diagnostic(span=$image, message="A `fill` image has no intrinsic width, so without `sizes` the browser assumes 100vw and requests the largest candidate. Pass `sizes`, or `mobileSize`/`desktopSize`.", severity="error")
+}

package/src/templates/next-default/biome.json

@@ -234,7 +234,8 @@
   "plugins": [
     "./.biome/plugins/no-anchor-element.grit",
     "./.biome/plugins/no-unnecessary-forwardref.grit",
-    "./.biome/plugins/no-relative-parent-imports.grit"
+    "./.biome/plugins/no-relative-parent-imports.grit",
+    "./.biome/plugins/no-fill-without-sizes.grit"
   ],
   "vcs": {
     "clientKind": "git",

package/src/templates/next-default/components/ui/image/index.tsx

@@ -98,7 +98,6 @@ const getFinalPlaceholder = (
  * Enhanced Image component with responsive sizing and automatic optimizations.
  *
  * Always use this component instead of next/image directly. Provides:
- * - Automatic responsive sizes generation
  * - Smart blur placeholders with aspect ratio support
  * - Performance optimizations (lazy loading by default)
  * - Priority flag for LCP images
@@ -147,14 +146,14 @@ export function Image({
   style,
   className,
   objectFit = "cover",
-  quality = 90,
+  quality = 75,
   alt = "",
   fill,
   block = !fill,
-  width = block ? 1 : undefined,
-  height = block ? 1 : undefined,
-  mobileSize = "100vw",
-  desktopSize = "100vw",
+  width,
+  height,
+  mobileSize,
+  desktopSize,
   sizes,
   src,
   unoptimized,
@@ -164,9 +163,18 @@ export function Image({
   priority = false,
   ...props
 }: ImageProps) {
-  // Generate responsive sizes if not provided
-  const finalSizes =
-    sizes || buildImageSizes({ base: mobileSize, desktop: desktopSize })
+  const responsiveSizes =
+    mobileSize || desktopSize
+      ? buildImageSizes({
+          base: mobileSize ?? "100vw",
+          desktop: desktopSize ?? mobileSize ?? "100vw",
+        })
+      : undefined
+
+  const hasIntrinsicSize = width !== undefined && height !== undefined
+  const finalSizes = sizes ?? responsiveSizes ?? (hasIntrinsicSize ? undefined : "100vw")
+  const finalWidth = width ?? (block ? 1 : undefined)
+  const finalHeight = height ?? (block ? 1 : undefined)
 
   // Early return after hooks
   if (!src) return null
@@ -194,8 +202,8 @@ export function Image({
     <NextImage
       ref={ref}
       fill={!block}
-      {...(width !== undefined && { width })}
-      {...(height !== undefined && { height })}
+      {...(finalWidth !== undefined && { width: finalWidth })}
+      {...(finalHeight !== undefined && { height: finalHeight })}
       priority={priority}
       quality={quality}
       alt={alt}
@@ -204,7 +212,7 @@ export function Image({
         ...style,
       }}
       className={cn(className, block && "block w-full")}
-      sizes={finalSizes}
+      {...(finalSizes && { sizes: finalSizes })}
       src={src}
       unoptimized={unoptimized || isSvg}
       draggable={false}

package/src/templates/next-default/next.config.ts

@@ -77,12 +77,18 @@ const nextConfig: NextConfig = {
     ],
   },
   images: {
-    dangerouslyAllowSVG: true,
-    remotePatterns: [],
+    remotePatterns: [
+      {
+        protocol: "https",
+        hostname: "cdn.sanity.io",
+      },
+    ],
     minimumCacheTTL: 60 * 60 * 24 * 30, // 30 days
-    qualities: [90],
+    qualities: [75, 90, 100],
     formats: ["image/avif", "image/webp"],
-    deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+    deviceSizes: [
+      640, 750, 828, 1080, 1200, 1320, 1620, 1920, 2048, 2560, 3024, 3456, 3840,
+    ],
     imageSizes: [16, 32, 48, 64, 96, 128, 256, 384],
   },
   headers: async () => [

package/src/templates/next-experiments/.biome/plugins/no-fill-without-sizes.grit

@@ -0,0 +1,11 @@
+language js
+
+or {
+	`<Image $attrs />`,
+	`<SanityImage $attrs />`
+} as $image where {
+	$attrs <: contains `fill`,
+	! $attrs <: contains `fill={false}`,
+	! $attrs <: contains or { `sizes`, `mobileSize`, `desktopSize` },
+	register_diagnostic(span=$image, message="A `fill` image has no intrinsic width, so without `sizes` the browser assumes 100vw and requests the largest candidate. Pass `sizes`, or `mobileSize`/`desktopSize`.", severity="error")
+}

package/src/templates/next-experiments/biome.json

@@ -229,7 +229,8 @@
   "plugins": [
     "./.biome/plugins/no-anchor-element.grit",
     "./.biome/plugins/no-unnecessary-forwardref.grit",
-    "./.biome/plugins/no-relative-parent-imports.grit"
+    "./.biome/plugins/no-relative-parent-imports.grit",
+    "./.biome/plugins/no-fill-without-sizes.grit"
   ],
   "vcs": {
     "clientKind": "git",