bsmnt 0.10.0 → 0.12.0

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/utils/rss.ts

@@ -0,0 +1,96 @@
+export interface RssFeedItem {
+	title: string;
+	link: string;
+	description?: string | undefined;
+	pubDate?: string | undefined;
+	authors?: string[] | undefined;
+	category?: string | undefined;
+}
+
+export interface RssFeedConfig {
+	title: string;
+	link: string;
+	description: string;
+	feedUrl: string;
+	language?: string;
+	items: RssFeedItem[];
+}
+
+function escapeXml(str: string): string {
+	return str
+		.replace(/&/g, "&")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&apos;");
+}
+
+export function generateRssFeed(config: RssFeedConfig): Response {
+	const {
+		title,
+		link,
+		description,
+		feedUrl,
+		language = "en-us",
+		items,
+	} = config;
+
+	const itemsXml = items
+		.map((item) => {
+			const lines = [
+				`      <title>${escapeXml(item.title)}</title>`,
+				`      <link>${escapeXml(item.link)}</link>`,
+				`      <guid isPermaLink="true">${escapeXml(item.link)}</guid>`,
+			];
+
+			if (item.description) {
+				lines.push(
+					`      <description>${escapeXml(item.description)}</description>`,
+				);
+			}
+
+			const pubDate = item.pubDate ? new Date(item.pubDate) : null;
+			if (pubDate && !Number.isNaN(pubDate.getTime())) {
+				lines.push(`      <pubDate>${pubDate.toUTCString()}</pubDate>`);
+			}
+
+			for (const author of item.authors ?? []) {
+				lines.push(`      <dc:creator>${escapeXml(author)}</dc:creator>`);
+			}
+
+			if (item.category) {
+				lines.push(`      <category>${escapeXml(item.category)}</category>`);
+			}
+
+			return `    <item>\n${lines.join("\n")}\n    </item>`;
+		})
+		.join("\n");
+
+	const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(title)}</title>
+    <link>${escapeXml(link)}</link>
+    <description>${escapeXml(description)}</description>
+    <language>${language}</language>
+    <atom:link href="${escapeXml(feedUrl)}" rel="self" type="application/rss+xml" />
+${itemsXml}
+  </channel>
+</rss>`;
+
+	return new Response(xml, {
+		headers: {
+			"Content-Type": "application/rss+xml",
+		},
+	});
+}
+
+export function rssErrorResponse(): Response {
+	return new Response(
+		'<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Error</title></channel></rss>',
+		{
+			status: 500,
+			headers: { "Content-Type": "application/xml" },
+		},
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/utils/sitemap.ts

@@ -0,0 +1,58 @@
+import { cacheLife, cacheTag } from "next/cache";
+import { PINNED_PAGE_ENTRIES } from "@/lib/integrations/sanity/pinned-pages";
+import { PAGE_SITEMAP_QUERY } from "@/lib/integrations/sanity/queries";
+import type { PAGE_SITEMAP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import { SITEMAP_TAG } from "@/lib/integrations/sanity/tags";
+import { getBaseUrl } from "./base-url";
+
+export const getSitemapBaseUrl = getBaseUrl;
+
+const getNormalizedPageSlug = (slug: string | null) => {
+	if (!slug || slug === "/") return "";
+	return slug.replace(/^\/+|\/+$/g, "");
+};
+
+export const getPagePath = (slug: string | null) => {
+	const normalizedSlug = getNormalizedPageSlug(slug);
+	return normalizedSlug ? `/${normalizedSlug}` : "/";
+};
+
+export const getPageUrl = (baseUrl: string, slug: string | null) =>
+	new URL(getPagePath(slug), baseUrl).toString();
+
+export const getMarkdownPath = (baseUrl: string, slug: string | null) => {
+	const normalizedSlug = getNormalizedPageSlug(slug);
+
+	return normalizedSlug
+		? `${baseUrl}/${normalizedSlug}.md`
+		: `${baseUrl}/index.md`;
+};
+
+// Cached and tagged, not per-request: robots.txt points every crawler here, so an
+// uncached read is a Sanity round trip per crawl hit.
+export const getSitemap = async () => {
+	"use cache";
+	const sanityModule = await import("@/lib/integrations/sanity/client");
+	const client = sanityModule?.client;
+
+	if (!client) return null;
+
+	const pages = await client
+		.fetch<PAGE_SITEMAP_QUERY_RESULT>(PAGE_SITEMAP_QUERY, {
+			pinnedIds: PINNED_PAGE_ENTRIES.map((entry) => entry.id),
+		})
+		.catch((error) => {
+			console.error("Error fetching the sitemap:", error);
+			return null;
+		});
+
+	if (pages) {
+		cacheTag(SITEMAP_TAG);
+	} else {
+		// No publish clears a failed read, and this prerenders — an outage at build
+		// time would otherwise bake in an empty sitemap for the full ~1y cacheLife.
+		cacheLife("hours");
+	}
+
+	return pages;
+};

package/src/modules/features/cms/sanity-pagebuilder-cache/files/proxy.ts

@@ -0,0 +1,90 @@
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import {
+	acceptHeaderRoutes,
+	ignoredPaths,
+	mdExtensionRoutes,
+} from "@/lib/integrations/sanity/markdown-proxy.config";
+
+export function proxy(request: NextRequest) {
+	const { pathname } = request.nextUrl;
+	const acceptHeader = request.headers.get("accept") || "";
+
+	if (ignoredPaths.some((p) => pathname.startsWith(p))) {
+		return NextResponse.next();
+	}
+
+	// Collapse repeated slashes before any rewrite, or the rewrite below would
+	// mask the alias (e.g. /foo//bar.md silently resolving to /foo/bar.md).
+	const collapsedPathname = pathname.replace(/\/{2,}/g, "/");
+	if (collapsedPathname !== pathname) {
+		const url = request.nextUrl.clone();
+		url.pathname = collapsedPathname;
+		return NextResponse.redirect(url, 308);
+	}
+
+	if (pathname === "/" && acceptHeader.includes("text/markdown")) {
+		const url = request.nextUrl.clone();
+		url.pathname = "/api/index.md";
+		return NextResponse.rewrite(url);
+	}
+
+	// 1. Rewrite .md extension URLs to API routes
+	//    e.g. /about.md → /api/about.md
+	for (const route of mdExtensionRoutes) {
+		const match = route.regex.exec(pathname);
+		const slug = match?.[1];
+		if (slug) {
+			const url = request.nextUrl.clone();
+			url.pathname = route.apiPath.replace("[slug]", slug);
+			return NextResponse.rewrite(url);
+		}
+	}
+
+	// 2. Accept: text/markdown — rewrite to markdown API route
+	if (acceptHeader.includes("text/markdown")) {
+		for (const route of acceptHeaderRoutes) {
+			const match = route.regex.exec(pathname);
+			const slug = match?.[1];
+			if (slug) {
+				const url = request.nextUrl.clone();
+				url.pathname = route.apiPath.replace("[slug]", slug);
+				return NextResponse.rewrite(url);
+			}
+		}
+	}
+
+	// 3. Add Link header for markdown discoverability on HTML page requests
+	const response = NextResponse.next();
+
+	if (pathname === "/") {
+		response.headers.set(
+			"Link",
+			'</index.md>; rel="alternate"; type="text/markdown"',
+		);
+		response.headers.set("Vary", "Accept");
+		return response;
+	}
+
+	for (const route of acceptHeaderRoutes) {
+		const match = route.regex.exec(pathname);
+		const slug = match?.[1];
+		if (slug) {
+			const mdUrl = route.publicPath.replace("[slug]", slug);
+			response.headers.set(
+				"Link",
+				`<${mdUrl}>; rel="alternate"; type="text/markdown"`,
+			);
+			response.headers.set("Vary", "Accept");
+			break;
+		}
+	}
+
+	return response;
+}
+
+export const config = {
+	matcher: [
+		"/((?!_next/static|_next/image|favicon.ico|sitemap.xml|sitemap.md|robots.txt).*)",
+	],
+};

package/src/modules/features/env/dotenvx/files/vercelignore

@@ -1,4 +1,9 @@
 # Never upload the private keys or local env files on `vercel deploy`.
 # (Encrypted .env / .env.production / .env.preview ARE uploaded — they're safe.)
+# Patterns stay unanchored so nested app/package dirs are covered too.
 .env.keys
 .env*.local
+# Exception: `vercel pull` writes its own env under .vercel/, and Next traces it
+# into the function bundles — stripping it breaks `deploy --prebuilt` with an
+# ENOENT on the remote build.
+!/.vercel/*.local

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/.env.example

@@ -56,8 +56,8 @@ NEXT_PUBLIC_SANITY_API_READ_TOKEN=""
 # Optional - for server-side mutations and visual editing
 # SANITY_PRIVATE_TOKEN=""
 
-# Optional - API version (defaults to 2024-03-15)
-# NEXT_PUBLIC_SANITY_API_VERSION="2024-03-15"
+# Optional - API version (defaults to 2025-02-19, the floor for Content Releases)
+# NEXT_PUBLIC_SANITY_API_VERSION="2025-02-19"
 
 
 # ============================================

package/src/templates/next-default/.github/workflows/ci.yml

@@ -41,7 +41,7 @@ jobs:
         run: bun install --frozen-lockfile
 
       - name: Type check
-        run: bun run typecheck:compare
+        run: bun run typecheck
 
       - name: Lint
         run: bun run lint

package/src/templates/next-default/.vscode/settings.json

@@ -58,7 +58,6 @@
 
   // General
   "files.eol": "\n",
-  // "typescript.experimental.useTsgo": true, // Disabled: tsgo doesn't support Next.js plugin
   "javascript.suggest.autoImports": true,
   // Disable Prettier to prevent silent formatter conflicts
   "prettier.enable": false,
@@ -90,7 +89,6 @@
 
   // TypeScript
   "typescript.suggest.autoImports": true,
-  "typescript.tsdk": "node_modules/typescript/lib",
 
   // Editor labels (fixed for .tsx files)
   "workbench.editor.customLabels.patterns": {

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

@@ -9,8 +9,7 @@
 import cn from "clsx"
 import NextImage, { type ImageProps as NextImageProps } from "next/image"
 import type { CSSProperties, Ref } from "react"
-
-const DESKTOP_BREAKPOINT = 1440
+import { buildImageSizes } from "@/lib/utils/image-sizes"
 
 /**
  * Enhanced Image component props extending Next.js Image.
@@ -99,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
@@ -148,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,
@@ -165,10 +163,18 @@ export function Image({
   priority = false,
   ...props
 }: ImageProps) {
-  // Generate responsive sizes if not provided
-  const finalSizes =
-    sizes ||
-    `(max-width: ${DESKTOP_BREAKPOINT}px) ${mobileSize}, ${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
@@ -196,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}
@@ -206,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/knip.json

@@ -20,5 +20,5 @@
     "zustand"
   ],
   "ignoreBinaries": ["op", "gh", "vercel"],
-  "ignoreFiles": [".agents/**", ".claude/**", "hooks/**"]
+  "ignoreFiles": [".agents/**", ".claude/**", "hooks/**", "lib/integrations/hubspot/**"]
 }

package/src/templates/next-default/lefthook.yml

@@ -11,7 +11,7 @@ pre-commit:
       stage_fixed: true
     typecheck:
       glob: '*.{ts,tsx}'
-      run: bunx tsgo --noEmit --incremental false
+      run: bunx tsc --noEmit --incremental false
       stage_fixed: false
 
 post-merge:

package/src/templates/next-default/lib/utils/README.md

@@ -5,10 +5,12 @@ Pure utility functions organized by concern.
 Use explicit imports for clarity and better tree-shaking:
 
 ```tsx
-import { clamp, lerp, mapRange } from '@/utils/math'
-import { slugify } from '@/utils/strings'
-import { generatePageMetadata } from '@/utils/metadata'
-import { tovw, torem, toem } from '@/utils/viewport'
+import { clamp, lerp, mapRange } from '@/lib/utils/math'
+import { slugify } from '@/lib/utils/strings'
+import { generatePageMetadata } from '@/lib/utils/metadata'
+import { tovw, torem, toem } from '@/lib/utils/viewport'
+import { buildImageSizes, buildGridImageSizes } from '@/lib/utils/image-sizes'
+import { useMergeRefs } from '@/lib/utils/merge-refs'
 ```
 
 ## Modules
@@ -18,8 +20,10 @@ import { tovw, torem, toem } from '@/utils/viewport'
 | `math` | `clamp`, `lerp`, `mapRange`, `modulo`, `normalize`, `distance` |
 | `easings` | All easing functions (`easeOutCubic`, etc.) |
 | `viewport` | `tovw`, `torem`, `toem` |
-| `strings` | `slugify`, `mergeRefs`, `capitalizeFirstLetter` |
+| `strings` | `slugify`, `capitalizeFirstLetter`, `twoDigits`, `numberWithCommas` |
 | `metadata` | `generatePageMetadata` |
+| `image-sizes` | `buildImageSizes`, `buildGridImageSizes` |
+| `merge-refs` | `mergeRefs`, `useMergeRefs`, `assignRef` |
 
 ## Common Patterns
 
@@ -37,4 +41,13 @@ toem(16, 14) // → "1.14em"
 
 // SEO
 export const metadata = generatePageMetadata({ title: 'About' })
+
+// next/image sizes — keys mirror the element's Tailwind variants
+buildImageSizes({ base: '100vw', desktop: '796px' })
+buildGridImageSizes({ base: 1, tablet: 2, desktop: 3 })
+
+// Refs — in a component, use the hook: an inline mergeRefs([...]) is a new
+// callback each render, so React detaches and reattaches every ref.
+const mergedRef = useMergeRefs([localRef, ref])
+return <input ref={mergedRef} />
 ```

package/src/templates/next-default/lib/utils/image-sizes.ts

@@ -0,0 +1,72 @@
+/** Mirrors the theme's `--breakpoint-*` scale, which clears Tailwind's defaults. */
+export const BASEMENT_BREAKPOINTS = {
+  mobile: 640,
+  tablet: 768,
+  "tablet-lg": 1024,
+  desktop: 1440,
+  "desktop-large": 1920,
+} as const
+
+export type BreakpointMap = Readonly<Record<string, number>>
+
+/** Mirrors the element's variants: `grid-cols-1 tablet:grid-cols-2` → `{ base: 1, tablet: 2 }`. */
+export type ByBreakpoint<
+  T,
+  B extends BreakpointMap = typeof BASEMENT_BREAKPOINTS,
+> = { base: T } & Partial<Record<Extract<keyof B, string>, T>>
+
+function columnWidth(columns: number): string {
+  return `${Math.round(100 / columns)}vw`
+}
+
+/**
+ * Widest first, since `sizes` takes the first matching condition and the last
+ * entry must be bare. `min-width` matches the Tailwind variant's boundary; a
+ * `max-width: <next> - 1` one would leave a fractional-pixel gap.
+ */
+function toSizes(
+  base: string,
+  overrides: Readonly<Record<string, string | undefined>>,
+  scale: BreakpointMap
+): string {
+  const conditions: string[] = []
+
+  for (const [name, min] of Object.entries(scale).sort(
+    ([, a], [, b]) => b - a
+  )) {
+    const value = overrides[name]
+    if (value !== undefined) {
+      conditions.push(`(min-width: ${min}px) ${value}`)
+    }
+  }
+
+  return [...conditions, base].join(", ")
+}
+
+/** Builds `sizes` from the CSS length the image renders at per breakpoint. */
+export function buildImageSizes<
+  B extends BreakpointMap = typeof BASEMENT_BREAKPOINTS,
+>(widths: ByBreakpoint<string, B>, breakpoints?: B): string {
+  const { base, ...overrides } = widths
+  return toSizes(base, overrides, breakpoints ?? BASEMENT_BREAKPOINTS)
+}
+
+/**
+ * Builds `sizes` from a grid's column count per breakpoint. Rounded: `sizes`
+ * only steers which srcset candidate the browser picks, and gaps make the real
+ * column narrower than `100 / N` anyway.
+ */
+export function buildGridImageSizes<
+  B extends BreakpointMap = typeof BASEMENT_BREAKPOINTS,
+>(columns: ByBreakpoint<number, B>, breakpoints?: B): string {
+  const { base, ...overrides } = columns
+  const widths: Record<string, string> = {}
+
+  for (const [name, count] of Object.entries(overrides)) {
+    if (count !== undefined) {
+      widths[name] = columnWidth(count)
+    }
+  }
+
+  return toSizes(columnWidth(base), widths, breakpoints ?? BASEMENT_BREAKPOINTS)
+}

package/src/templates/next-default/lib/utils/merge-refs.ts

@@ -0,0 +1,56 @@
+import { type Ref, type RefCallback, useRef } from "react"
+
+/** Returns the ref's own cleanup callback when it provides one (React 19). */
+export function assignRef<T>(
+  ref: Ref<T> | undefined,
+  value: T | null
+): ReturnType<RefCallback<T>> {
+  if (typeof ref === "function") {
+    return ref(value)
+  }
+  if (ref) {
+    ref.current = value
+  }
+  return undefined
+}
+
+/** Merges object/callback refs into one callback ref, with React 19 ref cleanup. */
+export function mergeRefs<T>(refs: (Ref<T> | undefined)[]): RefCallback<T> {
+  return (value) => {
+    const cleanups = refs.map((ref) => {
+      const cleanup = assignRef(ref, value)
+      return typeof cleanup === "function"
+        ? cleanup
+        : () => assignRef(ref, null)
+    })
+    return () => {
+      for (const cleanup of cleanups) {
+        cleanup()
+      }
+    }
+  }
+}
+
+/**
+ * Memoized {@link mergeRefs}, stable across renders for the same ref list.
+ * Compares the list here rather than passing it as `useMemo` deps: React only
+ * compares the common prefix, so a list that grows or shrinks would silently
+ * reuse the old callback and leave a ref unattached or stale.
+ */
+export function useMergeRefs<T>(refs: (Ref<T> | undefined)[]): RefCallback<T> {
+  const cache = useRef<{
+    refs: (Ref<T> | undefined)[]
+    merged: RefCallback<T>
+  } | null>(null)
+
+  if (
+    !cache.current ||
+    cache.current.refs.length !== refs.length ||
+    cache.current.refs.some((ref, i) => ref !== refs[i])
+  ) {
+    // Snapshot: a caller may hand us a persistent array it mutates in place.
+    cache.current = { refs: [...refs], merged: mergeRefs(refs) }
+  }
+
+  return cache.current.merged
+}

package/src/templates/next-default/lib/utils/strings.ts

@@ -1,11 +1,9 @@
 /**
  * String & Object Utilities
  *
- * Helper functions for string manipulation, object operations, and refs.
+ * Helper functions for string manipulation and object operations.
  */
 
-import type { Ref } from "react"
-
 // =============================================================================
 // STRING UTILITIES
 // =============================================================================
@@ -196,51 +194,3 @@ export function iterableObject(
     return value
   })
 }
-
-// =============================================================================
-// REF UTILITIES
-// =============================================================================
-
-/**
- * Merges multiple React refs into a single ref callback.
- *
- * Useful when you need to assign multiple refs to the same element,
- * such as combining a local ref with a forwarded ref.
- *
- * @param refs - Refs to merge (functions and ref objects supported)
- * @returns A ref callback that updates all provided refs
- *
- * @example
- * ```tsx
- * // Component that needs both local and forwarded ref
- * function MyComponent({ ref }: { ref: React.Ref<HTMLDivElement> }) {
- *   const localRef = useRef<HTMLDivElement>(null)
- *   const mergedRef = mergeRefs(localRef, ref)
- *
- *   return <div ref={mergedRef}>Content</div>
- * }
- *
- * // Forward ref pattern
- * const ForwardedComponent = forwardRef(MyComponent)
- * ```
- */
-export function mergeRefs<T>(...refs: (Ref<T> | undefined)[]): Ref<T> {
-  return (value) => {
-    const cleanups = refs.reduce<VoidFunction[]>((accumulator, ref) => {
-      if (typeof ref === "function") {
-        const cleanup = ref(value)
-        if (typeof cleanup === "function") {
-          accumulator.push(cleanup)
-        }
-      } else if (ref) {
-        ref.current = value
-      }
-
-      return accumulator
-    }, [])
-
-    return () => {
-      for (const cleanup of cleanups) cleanup()
-    }
-  }
-}