bsmnt 0.12.0 → 0.13.1

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/shared/anchor.ts

@@ -0,0 +1,75 @@
+const anchorSourceFields = [
+	"headline",
+	"heading",
+	"teaserHeading",
+	"title",
+	"label",
+] as const;
+
+const ANCHOR_MAX_LENGTH = 60;
+
+export const slugifyAnchor = (raw: string) =>
+	raw
+		.normalize("NFKD")
+		.replace(/[\u0300-\u036f]/g, "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.slice(0, ANCHOR_MAX_LENGTH)
+		.replace(/-+$/g, "");
+
+export const deriveAnchorId = (block: Record<string, unknown>) => {
+	for (const field of anchorSourceFields) {
+		const value = block[field];
+		if (typeof value === "string" && value.trim()) {
+			const slug = slugifyAnchor(value);
+			if (slug) return slug;
+		}
+	}
+
+	return "";
+};
+
+const explicitAnchorId = (block: Record<string, unknown>) =>
+	typeof block.anchorId === "string" ? slugifyAnchor(block.anchorId) : "";
+
+const NO_RESERVED_IDS: ReadonlySet<string> = new Set();
+
+export const reserveAnchorIds = (
+	blocks: readonly Record<string, unknown>[],
+): ReadonlySet<string> => {
+	const reserved = new Set<string>();
+
+	for (const block of blocks) {
+		const explicit = explicitAnchorId(block);
+		if (explicit) reserved.add(explicit);
+	}
+
+	return reserved;
+};
+
+export const resolveAnchorId = (
+	block: Record<string, unknown>,
+	taken: Set<string>,
+	reserved: ReadonlySet<string> = NO_RESERVED_IDS,
+) => {
+	const explicit = explicitAnchorId(block);
+	const base = explicit || deriveAnchorId(block);
+
+	if (!base) return "";
+
+	const isBlocked = (candidate: string) =>
+		taken.has(candidate) || (!explicit && reserved.has(candidate));
+
+	let candidate = base;
+	let suffix = 2;
+
+	while (isBlocked(candidate)) {
+		candidate = `${base}-${suffix}`;
+		suffix += 1;
+	}
+
+	taken.add(candidate);
+
+	return candidate;
+};

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/shared/block.ts

@@ -0,0 +1,46 @@
+import {
+	type DocumentDefinition,
+	defineType,
+	type FieldDefinition,
+	type FieldGroupDefinition,
+} from "sanity";
+import { presentationFields } from "./presentation";
+
+const presentationGroup: FieldGroupDefinition = {
+	name: "presentation",
+	title: "Presentation",
+};
+
+type BlockDefinition = Omit<DocumentDefinition, "type" | "fields" | "groups"> & {
+	fields: FieldDefinition[];
+	groups?: FieldGroupDefinition[];
+};
+
+const withPresentationGroup = (groups: FieldGroupDefinition[] | undefined) => {
+	if (!groups?.length) return undefined;
+	if (groups.some((group) => group.name === presentationGroup.name)) {
+		return groups;
+	}
+
+	return [...groups, presentationGroup];
+};
+
+/**
+ * Defines a page-builder block — `type: "document"` plus Anchor ID and
+ * Presentation Mode. Use instead of `defineType`.
+ */
+export const defineBlock = ({ fields, groups, ...rest }: BlockDefinition) => {
+	const blockGroups = withPresentationGroup(groups);
+
+	return defineType({
+		...rest,
+		type: "document",
+		...(blockGroups ? { groups: blockGroups } : {}),
+		fields: [
+			...fields,
+			...presentationFields(
+				blockGroups ? { group: presentationGroup.name } : undefined,
+			),
+		],
+	});
+};

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/shared/presentation.ts

@@ -0,0 +1,44 @@
+import { defineField, defineType } from "sanity";
+import { AnchorIdInput } from "@/lib/integrations/sanity/components/anchor-id-input";
+import { PresentationInput } from "@/lib/integrations/sanity/components/presentation-input";
+
+export const presentation = defineType({
+	name: "presentation",
+	title: "Presentation Mode",
+	type: "object",
+	components: { input: PresentationInput },
+	fields: [
+		defineField({
+			name: "paddingTop",
+			title: "Padding top",
+			type: "string",
+		}),
+		defineField({
+			name: "paddingBottom",
+			title: "Padding bottom",
+			type: "string",
+		}),
+	],
+});
+
+export const presentationFields = (options?: { group?: string }) => [
+	defineField({
+		name: "anchorId",
+		title: "Anchor ID",
+		type: "string",
+		...(options?.group ? { group: options.group } : {}),
+		components: { input: AnchorIdInput },
+		description:
+			"Links to this block as /page#your-anchor-id. Leave empty to generate it from the block title.",
+		validation: (Rule) =>
+			Rule.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { name: "anchor id" }).error(
+				"Use lowercase letters, numbers and dashes only (e.g. how-it-works)",
+			),
+	}),
+	defineField({
+		name: "presentation",
+		title: "Presentation Mode",
+		type: "presentation",
+		...(options?.group ? { group: options.group } : {}),
+	}),
+];

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/shared/spacing.ts

@@ -0,0 +1,164 @@
+export const spacingBreakpoints = ["mobile", "tablet", "desktop"] as const;
+
+export type SpacingBreakpoint = (typeof spacingBreakpoints)[number];
+
+export const spacingBreakpointMinWidth: Record<SpacingBreakpoint, number> = {
+	mobile: 0,
+	tablet: 768,
+	desktop: 1440,
+};
+
+export type SpacingStep = {
+	key: string;
+	name: string;
+	isDefault: boolean;
+} & Record<SpacingBreakpoint, number>;
+
+const fallbackSpacingStep: SpacingStep = {
+	key: "md",
+	name: "MD",
+	mobile: 24,
+	tablet: 28,
+	desktop: 32,
+	isDefault: true,
+};
+
+export const defaultSpacingSteps: SpacingStep[] = [
+	{
+		key: "xs",
+		name: "XS",
+		mobile: 12,
+		tablet: 14,
+		desktop: 16,
+		isDefault: false,
+	},
+	{
+		key: "sm",
+		name: "SM",
+		mobile: 16,
+		tablet: 20,
+		desktop: 24,
+		isDefault: false,
+	},
+	fallbackSpacingStep,
+	{
+		key: "lg",
+		name: "LG",
+		mobile: 32,
+		tablet: 40,
+		desktop: 48,
+		isDefault: false,
+	},
+	{
+		key: "xl",
+		name: "XL",
+		mobile: 48,
+		tablet: 64,
+		desktop: 80,
+		isDefault: false,
+	},
+];
+
+export type SpacingStepSource = {
+	_key?: string | null;
+	name?: string | null;
+	mobile?: number | null;
+	tablet?: number | null;
+	desktop?: number | null;
+	isDefault?: boolean | null;
+};
+
+export const spacingStepKey = (raw: string) =>
+	raw
+		.toLowerCase()
+		.replace(/[^a-z0-9-]/g, "")
+		.slice(0, 40);
+
+export const spacingVariable = (key: string) => `--section-space-${key}`;
+
+export const defaultSpacingVariable = spacingVariable("default");
+
+const FALLBACK_PADDING = "2.5rem";
+
+const readPx = (value: number | null | undefined) =>
+	typeof value === "number" && Number.isFinite(value) && value >= 0
+		? Math.round(value)
+		: null;
+
+export const resolveSpacingSteps = (
+	source?: readonly SpacingStepSource[] | null,
+): SpacingStep[] => {
+	const steps = (source ?? []).flatMap<SpacingStep>((entry) => {
+		const key = spacingStepKey(entry?._key ?? "");
+		const name = entry?.name?.trim();
+		const desktop = readPx(entry?.desktop);
+
+		if (!(key && name && desktop !== null)) return [];
+
+		return [
+			{
+				key,
+				name,
+				desktop,
+				tablet: readPx(entry?.tablet) ?? desktop,
+				mobile: readPx(entry?.mobile) ?? desktop,
+				isDefault: entry?.isDefault === true,
+			},
+		];
+	});
+
+	if (steps.length === 0) return defaultSpacingSteps;
+
+	if (steps.some((step) => step.isDefault)) {
+		let seen = false;
+		return steps.map((step) => {
+			const isDefault = step.isDefault && !seen;
+			if (isDefault) seen = true;
+			return { ...step, isDefault };
+		});
+	}
+
+	const middle = Math.floor((steps.length - 1) / 2);
+	return steps.map((step, index) => ({ ...step, isDefault: index === middle }));
+};
+
+export const getDefaultSpacingStep = (steps: SpacingStep[]): SpacingStep =>
+	steps.find((step) => step.isDefault) ?? steps[0] ?? fallbackSpacingStep;
+
+export const spacingPaddingValue = (key?: string | null) => {
+	const safe = key ? spacingStepKey(key) : "";
+	const fallback = `var(${defaultSpacingVariable}, ${FALLBACK_PADDING})`;
+
+	if (!safe || safe === "default") return fallback;
+
+	return `var(${spacingVariable(safe)}, ${fallback})`;
+};
+
+export const spacingScaleCss = (steps: SpacingStep[]) => {
+	const defaultStep = getDefaultSpacingStep(steps);
+
+	const rule = (breakpoint: SpacingBreakpoint) => {
+		const declarations = [
+			...steps.map(
+				(step) => `${spacingVariable(step.key)}:${step[breakpoint]}px`,
+			),
+			`${defaultSpacingVariable}:${defaultStep[breakpoint]}px`,
+		].join(";");
+
+		return `:root{${declarations}}`;
+	};
+
+	return [
+		rule("mobile"),
+		`@media (min-width:${spacingBreakpointMinWidth.tablet}px){${rule("tablet")}}`,
+		`@media (min-width:${spacingBreakpointMinWidth.desktop}px){${rule("desktop")}}`,
+	].join("");
+};
+
+export const spacingStepOptions = (steps: SpacingStep[]) =>
+	steps.map((step) => ({
+		value: step.key,
+		title: `${step.name} (${step.desktop}px · ${step.mobile}px mobile)${
+			step.isDefault ? " · default" : ""
+		}`,
+	}));

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/singletons.ts

@@ -3,6 +3,7 @@ import {
 	footerIcon,
 	navbarIcon,
 	pageListIcon,
+	spacingSettingsIcon,
 	structuredDataIcon,
 } from "./icons";
 
@@ -42,6 +43,12 @@ export const singletonLayout = [
 		title: "Structured Data",
 		icon: structuredDataIcon,
 	},
+	{
+		schemaType: "spacingSettings",
+		documentId: "spacingSettings",
+		title: "Spacing Scale",
+		icon: spacingSettingsIcon,
+	},
 ] as const;
 
 export const singletonComponentTypes: Set<string> = new Set(

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/structure.ts

@@ -252,7 +252,7 @@ export const structure: StructureResolver = (S, context) =>
 
 			S.divider(),
 
-			// GROUP 2: Content -- authors, blog categories
+			// GROUP 2: Content -- blog posts, authors, blog categories
 			S.listItem()
 				.title("Content")
 				.icon(contentFolderIcon)
@@ -260,6 +260,9 @@ export const structure: StructureResolver = (S, context) =>
 					S.list()
 						.title("Content")
 						.items([
+							S.documentTypeListItem("blogContent")
+								.title("Blog Posts")
+								.icon(contentIcon),
 							S.documentTypeListItem("author")
 								.title("Authors")
 								.icon(authorIcon),
@@ -299,9 +302,6 @@ export const structure: StructureResolver = (S, context) =>
 							S.documentTypeListItem("gatedContent")
 								.title("Gated Content")
 								.icon(gatedContentIcon),
-							S.documentTypeListItem("blogContent")
-								.title("Blog Content")
-								.icon(contentIcon),
 							S.divider(),
 							S.documentTypeListItem("studioPreview")
 								.title("Component Previews")

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/tags.ts

@@ -8,12 +8,14 @@ export const SANITY_NAVBAR_TAG = "navbar";
 export const SANITY_FOOTER_TAG = "footer";
 export const SANITY_COMPANY_DATA_TAG = "companyData";
 export const SANITY_STRUCTURED_DATA_TAG = "structuredData";
+export const SANITY_SPACING_SETTINGS_TAG = "spacingSettings";
 
 export const SANITY_LAYOUT_TAGS = [
 	SANITY_NAVBAR_TAG,
 	SANITY_FOOTER_TAG,
 	SANITY_COMPANY_DATA_TAG,
 	SANITY_STRUCTURED_DATA_TAG,
+	SANITY_SPACING_SETTINGS_TAG,
 ] as const;
 
 export const SANITY_REDIRECTS_TAG = "redirect";

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

@@ -0,0 +1,25 @@
+import { ketchBootUrl } from "@/lib/integrations/ketch/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 { isKetchConfigured } from '@/integrations/check-integration'
+ *
+ * if (isKetchConfigured()) {
+ *   // Only render the CMP once it's actually configured
+ * }
+ * ```
+ */
+
+/**
+ * Check if Ketch (consent management) is configured. Derived from env.ts, not
+ * a second read of `process.env`.
+ */
+export function isKetchConfigured(): boolean {
+  return Boolean(ketchBootUrl)
+}

package/src/modules/features/consent/ketch/files/lib/integrations/ketch/README.md

@@ -0,0 +1,70 @@
+# Ketch consent integration (CMP)
+
+[Ketch](https://app.ketch.com) is the consent management platform. It decides,
+per visitor and per region, whether the site may run analytics or marketing
+trackers. **No tracking script may fire without asking it first.**
+
+## 1. Environment
+
+Both codes are public — they appear in the boot URL in the page source — so
+they go in as plain values:
+
+```bash
+NEXT_PUBLIC_KETCH_ORG_CODE=
+NEXT_PUBLIC_KETCH_PROPERTY_CODE=
+```
+
+Get them from the Ketch dashboard at https://app.ketch.com, or read them out
+of the boot URL if all you have is the raw `<script>` snippet:
+
+```
+https://global.ketchcdn.com/web/v3/config/<org>/<property>/boot.js
+```
+
+## 2. Checking consent
+
+One helper, always — categories are `essential`, `analytics`, `marketing`:
+
+```tsx
+const { hasConsent } = useConsent() // @/lib/integrations/ketch/use-consent
+
+useEffect(() => {
+  if (!hasConsent("analytics")) return
+  const tracker = start()
+  return () => tracker.stop() // this is what makes revocation work
+}, [hasConsent])
+```
+
+It returns `false` until Ketch resolves, so a tracker written this way cannot
+fire early. Never read `window.ketch`, cookies or `localStorage` directly —
+outside React, subscribe to `consentStore` from `./consent-store` instead.
+
+Map each tracker to a category in `categories.ts`'s `TRACKER_CONSENT_CATEGORY`
+so the mapping lives in one place and is reviewable. See the
+`ketch-consent-check` agent skill for the full walkthrough (loader shape,
+cleanup, SDKs without teardown).
+
+Preferences are reachable from `<ConsentPreferencesButton />` in the footer
+and from Ketch's own floating button (kept by default, since the footer entry
+point isn't guaranteed on every project this integration is added to). Hide
+the floating button in `ketch-experience.css` only once another entry point
+is confirmed to exist — see the `ketch-consent-setup` skill's UI reference.
+
+## 3. Region behaviour
+
+Ketch resolves a jurisdiction from the visitor's IP — nothing to configure in
+code. EEA/UK/Switzerland, California and Quebec are opt-in (nothing runs until
+the visitor accepts); Canada and 14 US states are opt-out (on until refused);
+everywhere else falls to `default`, which is notice-only. Because the helper
+stays denied until Ketch confirms, the site's own trackers wait for the
+record in every region.
+
+In a notice-only region the purpose toggles render locked as "Always Active"
+and the Accept/Reject buttons have nothing to change — that is the
+jurisdiction's configuration, not a bug.
+
+Also true for opt-out regions: consent is granted automatically with no
+banner interaction, so the banner won't come back on reload either. To test
+the real Accept/Reject UI from a region that defaults to notice-only, append
+`?ketch_jurisdiction=gdpr` to the URL — see the `ketch-consent-setup` skill's
+UI reference for the full mechanism.

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

@@ -0,0 +1,20 @@
+export const CONSENT_CATEGORIES = {
+  essential: "essential_services",
+  analytics: "analytics",
+  marketing: "targeted_advertising",
+} as const
+
+export type ConsentCategory = keyof typeof CONSENT_CATEGORIES
+
+export type KetchPurposeCode = (typeof CONSENT_CATEGORIES)[ConsentCategory]
+
+export const CONSENT_CATEGORY_LIST = Object.keys(
+  CONSENT_CATEGORIES
+) as ConsentCategory[]
+
+export const TRACKER_CONSENT_CATEGORY = {} as const satisfies Record<
+  string,
+  ConsentCategory
+>
+
+export type TrackedService = keyof typeof TRACKER_CONSENT_CATEGORY

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

@@ -0,0 +1,107 @@
+import {
+  CONSENT_CATEGORIES,
+  CONSENT_CATEGORY_LIST,
+  type ConsentCategory,
+} from "./categories"
+import type { KetchConsent, KetchJurisdictionEvent, KetchWindow } from "./types"
+
+export type ConsentSnapshot = {
+  isResolved: boolean
+  jurisdiction: string | null
+  granted: Readonly<Record<ConsentCategory, boolean>>
+}
+
+const denyAll = () =>
+  Object.fromEntries(
+    CONSENT_CATEGORY_LIST.map((category) => [category, false])
+  ) as Record<ConsentCategory, boolean>
+
+const UNRESOLVED: ConsentSnapshot = {
+  isResolved: false,
+  jurisdiction: null,
+  granted: denyAll(),
+}
+
+let snapshot: ConsentSnapshot = UNRESOLVED
+let isListening = false
+const listeners = new Set<() => void>()
+
+const notify = () => {
+  for (const listener of listeners) listener()
+}
+
+const getKetchWindow = () =>
+  typeof window === "undefined" ? null : (window as KetchWindow)
+
+const sendKetchCommand = (...command: unknown[]) => {
+  const ketchWindow = getKetchWindow()
+  if (!ketchWindow) return
+
+  if (typeof ketchWindow.ketch === "function") {
+    ketchWindow.ketch(...command)
+    return
+  }
+
+  ketchWindow.semaphore = ketchWindow.semaphore ?? []
+  ketchWindow.semaphore.push(command)
+}
+
+const readGranted = (consent: KetchConsent) => {
+  const purposes = consent?.purposes ?? {}
+  const granted = denyAll()
+
+  for (const category of CONSENT_CATEGORY_LIST) {
+    const value = purposes[CONSENT_CATEGORIES[category]]
+    granted[category] = value === true || value === "true"
+  }
+
+  return granted
+}
+
+const isSameGranted = (
+  a: Readonly<Record<ConsentCategory, boolean>>,
+  b: Readonly<Record<ConsentCategory, boolean>>
+) => CONSENT_CATEGORY_LIST.every((category) => a[category] === b[category])
+
+const handleConsent = (consent: KetchConsent) => {
+  const granted = readGranted(consent)
+  if (snapshot.isResolved && isSameGranted(snapshot.granted, granted)) return
+
+  snapshot = { ...snapshot, isResolved: true, granted }
+  notify()
+}
+
+const handleJurisdiction = (event: KetchJurisdictionEvent) => {
+  const code = typeof event === "string" ? event : event?.code
+  if (!code || code === snapshot.jurisdiction) return
+
+  snapshot = { ...snapshot, jurisdiction: code }
+  notify()
+}
+
+const startListening = () => {
+  if (isListening || !getKetchWindow()) return
+  isListening = true
+
+  sendKetchCommand("on", "consent", handleConsent)
+  sendKetchCommand("on", "jurisdiction", handleJurisdiction)
+}
+
+export const consentStore = {
+  subscribe: (listener: () => void) => {
+    startListening()
+    listeners.add(listener)
+
+    return () => {
+      listeners.delete(listener)
+    }
+  },
+  getSnapshot: () => snapshot,
+  getServerSnapshot: () => UNRESOLVED,
+  hasConsent: (category: ConsentCategory) => snapshot.granted[category],
+  openPreferences: () => {
+    sendKetchCommand("showConsent", {
+      displayHint: "experiences.consent.modal",
+    })
+  },
+}

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

@@ -0,0 +1,20 @@
+const KETCH_CODE_PATTERN = /^[a-z0-9_-]+$/i
+
+const readCode = (value: string | undefined) => {
+  const code = value?.trim()
+  if (!code || !KETCH_CODE_PATTERN.test(code)) return ""
+  return code
+}
+
+export const ketchOrganizationCode = readCode(
+  process.env.NEXT_PUBLIC_KETCH_ORG_CODE
+)
+
+export const ketchPropertyCode = readCode(
+  process.env.NEXT_PUBLIC_KETCH_PROPERTY_CODE
+)
+
+export const ketchBootUrl =
+  ketchOrganizationCode && ketchPropertyCode
+    ? `https://global.ketchcdn.com/web/v3/config/${ketchOrganizationCode}/${ketchPropertyCode}/boot.js`
+    : null