@majordigital/create-acorn 1.3.0 → 1.3.1

package/storyblok/storyblok-api/src/lib/storyblok/fetch/fetchIcons.ts

@@ -0,0 +1,108 @@
+import type { StoryblokStory } from 'storyblok-generate-ts';
+
+import { getStoryblokApi } from '@/lib/storyblok';
+import snapshot from '@/snapshot/icons.json';
+import type { PageIcon } from '@/types/components';
+
+import type { ICustomSbStoriesParams } from '../types';
+import {
+	DEFAULT_EXCLUDING_FIELDS,
+	DEFAULT_REVALIDATE,
+	MAX_STORIES_PER_PAGE,
+} from './config';
+
+import type { PageStoryblok } from '.storyblok/types/338885/storyblok-components';
+
+/**
+ * Maps Storyblok icon stories to PageIcon objects for UI use.
+ */
+export const mapIcons = (
+	icons: ReadonlyArray<StoryblokStory<PageStoryblok>>
+): PageIcon[] => {
+	if (!icons || icons.length === 0) return [];
+
+	return icons
+		.map(({ slug, content }) => {
+			if (!slug || !content) return null;
+
+			const { title, icon, icon_small } = content;
+			if (!icon || !icon.filename) return null;
+
+			const { id, filename, alt } = icon;
+			const filenameSmall = icon_small?.filename;
+
+			return {
+				id: String(id),
+				url: filename,
+				url_small: filenameSmall,
+				alt: alt || title || '',
+				slug,
+			};
+		})
+		.filter(Boolean) as PageIcon[];
+};
+
+/**
+ * Fetches icon stories from Storyblok and maps them to PageIcon objects.
+ */
+export const fetchIcons = async (): Promise<PageIcon[]> => {
+	// 1) Production build → static snapshot (fast, zero API hits)
+	if (process.env.NODE_ENV === 'production') {
+		return snapshot as PageIcon[];
+	}
+
+	// 2) Filter for icons that actually have an image set
+	const filter_query: NonNullable<ICustomSbStoriesParams['filter_query']> = {
+		hide_from_search: { in: 'false' },
+		'icon.filename': { is: 'not_empty' },
+	};
+
+	// 3) Build base params (published, with cv)
+	const per_page = MAX_STORIES_PER_PAGE;
+	const storyblokApi = getStoryblokApi();
+
+	const baseParams = {
+		version: 'published' as const,
+		content_type: 'page',
+		filter_query,
+		excluding_fields: DEFAULT_EXCLUDING_FIELDS,
+		per_page,
+	};
+
+	// 4) First page (direct API call)
+	const firstParams = { ...baseParams, page: 1 };
+	const first = await storyblokApi.get('cdn/stories', firstParams, {
+		next: {
+			revalidate: DEFAULT_REVALIDATE,
+		},
+	});
+
+	const total = first?.total ?? 0;
+	const firstStories = first?.data?.stories ?? [];
+
+	// 5) Remaining pages (direct API call, loop-free)
+	const maxPage = Math.ceil(total / per_page);
+	const rest =
+		maxPage <= 1
+			? []
+			: await Promise.all(
+					Array.from({ length: maxPage - 1 }, (_, idx) => {
+						const pageParams = { ...baseParams, page: 2 + idx };
+						return storyblokApi.get('cdn/stories', pageParams, {
+							next: {
+								revalidate: DEFAULT_REVALIDATE,
+							},
+						});
+					})
+				);
+
+	// 6) Combine and map to PageIcon[]
+	const allStoriesRaw = [
+		firstStories,
+		...rest.flatMap(r => r.data?.stories ?? []),
+	];
+	const iconStories =
+		allStoriesRaw as unknown as StoryblokStory<PageStoryblok>[];
+
+	return mapIcons(iconStories);
+};

package/storyblok/storyblok-api/src/lib/storyblok/fetch/fetchPaths.ts

@@ -0,0 +1,164 @@
+import type { ISbLinksParams } from 'storyblok-js-client';
+
+import { getStoryblokApi } from '@/lib/storyblok';
+
+import type {
+	ICustomSbStoriesParams,
+	Paths,
+	StoryblokLinkObject,
+} from '../types';
+import {
+	DEFAULT_EXCLUDING_FIELDS,
+	DEFAULT_REVALIDATE,
+	ignoreDynamicRoutes,
+	ignoreDynamicStories,
+	ignoreListingRoutes,
+	LINKS_PER_PAGE,
+	reservedSlugs,
+} from './config';
+import { fetchStories as fetchStoriesList } from './fetchStories';
+
+// --- Types local to this module
+type LinksResponse = {
+	total: number;
+	data: { links: Record<string, StoryblokLinkObject> };
+};
+
+function isStoryblokLinkObject(v: unknown): v is StoryblokLinkObject {
+	if (typeof v !== 'object' || v === null) return false;
+	const obj = v as Record<string, unknown>;
+	return typeof obj.id === 'number' && typeof obj.slug === 'string';
+}
+
+function asLinksMap(src: unknown): Record<string, StoryblokLinkObject> {
+	if (typeof src !== 'object' || src === null) return {};
+	const obj = src as Record<string, unknown>;
+
+	return Object.entries(obj)
+		.filter(([, v]) => isStoryblokLinkObject(v))
+		.reduce<Record<string, StoryblokLinkObject>>((acc, [k, v]) => {
+			acc[k] = v as StoryblokLinkObject;
+			return acc;
+		}, {});
+}
+
+const getPaths = async (): Promise<Record<string, StoryblokLinkObject>> => {
+	const storyblokApi = getStoryblokApi();
+	const params: ISbLinksParams = {
+		version: 'published',
+		per_page: LINKS_PER_PAGE,
+		page: 1,
+	};
+
+	// First page (direct API call)
+	const firstPage = (await storyblokApi.get('cdn/links', params, {
+		next: {
+			revalidate: DEFAULT_REVALIDATE,
+		},
+	})) as LinksResponse;
+
+	const total = firstPage?.total ?? 0;
+	const effectivePerPage = params.per_page ?? LINKS_PER_PAGE;
+
+	// If everything fits, just return this page’s links
+	if (total <= effectivePerPage) {
+		return asLinksMap(firstPage.data.links);
+	}
+
+	// Fetch remaining pages in parallel (direct API call per page) — loop-free
+	const maxPage = Math.ceil(total / effectivePerPage);
+	const otherPages =
+		maxPage <= 1
+			? []
+			: await Promise.all(
+					Array.from({ length: maxPage - 1 }, (_, idx) => {
+						const pageParams: ISbLinksParams = {
+							...params,
+							page: 2 + idx,
+						};
+						return storyblokApi.get('cdn/links', pageParams, {
+							next: {
+								revalidate: DEFAULT_REVALIDATE,
+							},
+						}) as Promise<LinksResponse>;
+					})
+				);
+
+	// Merge all pages into a single map — loop-free
+	const allLinksMap: Record<string, StoryblokLinkObject> = [
+		firstPage,
+		...otherPages,
+	]
+		.map(res => asLinksMap(res.data.links))
+		.reduce<Record<string, StoryblokLinkObject>>(
+			(acc, cur) => ({ ...acc, ...cur }),
+			{}
+		);
+
+	return allLinksMap;
+};
+
+const filterPaths = (
+	linksMap: Record<string, StoryblokLinkObject>
+): Paths[] => {
+	const items: StoryblokLinkObject[] = Object.values(linksMap);
+
+	return items
+		.filter(link => !link.is_folder)
+		.filter(link => link.published)
+		.filter(link => {
+			// ignore reserved slugs and routes configured to be ignored
+			if (reservedSlugs.includes(link.slug)) return false;
+			if (ignoreDynamicRoutes.some(r => link.slug.startsWith(`${r}/`)))
+				return false;
+			if (
+				ignoreListingRoutes.some(parts => link.slug === parts.join('/'))
+			)
+				return false;
+			return true;
+		})
+		.filter(
+			link =>
+				!ignoreDynamicStories.includes(link.slug.split('/')[0] || '')
+		)
+		.map(link => ({ slug: link.slug.split('/') }));
+};
+
+export const fetchPaths = async (): Promise<Paths[]> => {
+	const linksMap = await getPaths();
+	return filterPaths(linksMap).sort((a, b) =>
+		a.slug.join('/').localeCompare(b.slug.join('/'))
+	);
+};
+
+// Build /{slug}/page/2..N for list pages with minimal cost
+export const fetchPaginationPaths = async ({
+	slug,
+	content_type,
+	limit,
+}: {
+	slug: string;
+	content_type: ICustomSbStoriesParams['content_type'];
+	limit: number; // posts per page
+}): Promise<Paths[]> => {
+	// Ask only for the *total* cheaply (per_page: 1, excluding heavy fields)
+	const config: ICustomSbStoriesParams = {
+		content_type,
+		per_page: 1,
+		limit: 1, // keep our fetchStories cap low; we only need total
+		page: 1,
+		filter_query: { hide_from_search: { is: 'false' } },
+		sort_by: 'content.date:desc',
+		excluding_fields: DEFAULT_EXCLUDING_FIELDS,
+	};
+
+	const stories = await fetchStoriesList({ config });
+	const totalItems = stories?.total ?? 0;
+	const totalPages = totalItems > 0 ? Math.ceil(totalItems / limit) : 1;
+
+	if (totalPages <= 1) return [];
+
+	return Array.from({ length: totalPages - 1 }).map((_, i) => ({
+		slug: [slug, 'page', String(i + 2)],
+	}));
+};

package/storyblok/storyblok-api/src/lib/storyblok/fetch/fetchSitemap.ts

@@ -0,0 +1,103 @@
+import type { MetadataRoute } from 'next';
+
+import { siteConfig } from '@/lib/config';
+import { getStoryblokApi } from '@/lib/storyblok';
+
+import type { StoryblokLinkObject } from '../types';
+import {
+	DEFAULT_REVALIDATE,
+	ignoreDynamicRoutes,
+	LINKS_PER_PAGE,
+	reservedSlugs,
+} from './config';
+
+// Response shape from Storyblok Links API
+type LinksResponse = {
+	total: number;
+	data: { links: Record<string, StoryblokLinkObject> };
+};
+
+function asLinksMap(src: unknown): Record<string, StoryblokLinkObject> {
+	if (typeof src !== 'object' || src === null) return {};
+	const obj = src as Record<string, unknown>;
+	return Object.entries(obj)
+		.filter(([, v]) => {
+			if (typeof v !== 'object' || v === null) return false;
+			const o = v as Record<string, unknown>;
+			return typeof o.id === 'number' && typeof o.slug === 'string';
+		})
+		.reduce<Record<string, StoryblokLinkObject>>((acc, [k, v]) => {
+			acc[k] = v as StoryblokLinkObject;
+			return acc;
+		}, {});
+}
+export const fetchSitemap = async (): Promise<MetadataRoute.Sitemap> => {
+	const storyblokApi = getStoryblokApi();
+
+	// 1) First page (direct API call)
+	const params = {
+		version: 'published',
+		per_page: LINKS_PER_PAGE,
+		page: 1,
+	} as const;
+
+	const first = (await storyblokApi.get('cdn/links', params, {
+		next: {
+			revalidate: DEFAULT_REVALIDATE,
+		},
+	})) as LinksResponse;
+
+	const total = first?.total ?? 0;
+	const perPage = params.per_page ?? LINKS_PER_PAGE;
+
+	// 2) Paginate (direct API call per page)
+	const maxPage = Math.ceil(total / perPage);
+	const rest: LinksResponse[] =
+		maxPage <= 1
+			? []
+			: await Promise.all(
+					Array.from({ length: maxPage - 1 }, (_, idx) => {
+						const pageParams = { ...params, page: 2 + idx };
+						return storyblokApi.get('cdn/links', pageParams, {
+							next: {
+								revalidate: DEFAULT_REVALIDATE,
+							},
+						}) as Promise<LinksResponse>;
+					})
+				);
+
+	// 3) Merge all link maps
+	const linksMap: Record<string, StoryblokLinkObject> = [first, ...rest]
+		.map(r => asLinksMap(r.data.links))
+		.reduce<Record<string, StoryblokLinkObject>>(
+			(acc, cur) => ({ ...acc, ...cur }),
+			{}
+		);
+
+	// 4) Filter & map to sitemap entries
+	const baseUrl = siteConfig.url.replace(/\/+$/, '');
+
+	const entries: MetadataRoute.Sitemap = Object.values(linksMap)
+		.filter(l => !l.is_folder)
+		.filter(l => l.published)
+		.filter(l => {
+			if (reservedSlugs.includes(l.slug)) return false;
+			if (ignoreDynamicRoutes.some(r => l.slug.startsWith(`${r}/`)))
+				return false;
+			return true;
+		})
+		.map(link => {
+			const isHome = link.slug === '' || link.slug === 'home';
+			const url = isHome ? `${baseUrl}/` : `${baseUrl}/${link.slug}`;
+			return {
+				url,
+				lastModified: new Date(),
+				changeFrequency: isHome ? 'daily' : 'weekly',
+				priority: isHome ? 1.0 : 0.7,
+			} as MetadataRoute.Sitemap[number];
+		})
+		// 5) Deterministic ordering
+		.sort((a, b) => a.url.localeCompare(b.url));
+
+	return entries;
+};

package/storyblok/storyblok-api/src/lib/storyblok/fetch/fetchStories.ts

@@ -0,0 +1,105 @@
+import { getStoryblokApi } from '@storyblok/react/rsc';
+import type { ISbStories } from 'storyblok-js-client';
+
+import { isDraftEnabled } from '@/lib/utils';
+
+import type {
+	ICustomSbStoriesParams,
+	StoryblokServiceDefaults,
+} from '../types';
+import {
+	DEFAULT_EXCLUDING_FIELDS,
+	DEFAULT_REVALIDATE,
+	MAX_STORIES_PER_PAGE,
+} from './config';
+
+/**
+ * Fetch a paginated list of Storyblok stories (cached).
+ */
+export const fetchStories = async ({
+	config,
+	draftMode,
+}: {
+	config: ICustomSbStoriesParams;
+	draftMode?: StoryblokServiceDefaults['draftMode'];
+}): Promise<ISbStories | null> => {
+	const isDraft = isDraftEnabled(draftMode);
+	const cv = isDraft ? Date.now() : undefined;
+
+	// 1) per_page + cap (min 1, max 100)
+	const requested = config.per_page ?? MAX_STORIES_PER_PAGE;
+	const limitCap =
+		typeof config.limit === 'number'
+			? Math.min(config.limit, MAX_STORIES_PER_PAGE)
+			: MAX_STORIES_PER_PAGE;
+	const per_page = Math.max(
+		1,
+		Math.min(requested, limitCap, MAX_STORIES_PER_PAGE)
+	);
+
+	const { limit, ...configWithoutLimit } = config;
+	const pageStart = configWithoutLimit.page ?? 1;
+
+	// Base params passed to Storyblok
+	const baseParams = {
+		version: (isDraft ? 'draft' : 'published') as 'draft' | 'published',
+		cv,
+		...configWithoutLimit,
+		excluding_fields: config.excluding_fields ?? DEFAULT_EXCLUDING_FIELDS,
+		per_page,
+	};
+
+	// 2) First page (direct API call)
+	const storyblokApi = getStoryblokApi();
+	const firstParams = { ...baseParams, page: pageStart };
+	const firstPage = await storyblokApi.getStories(firstParams, {
+		next: {
+			revalidate: DEFAULT_REVALIDATE,
+		},
+	});
+
+	const total = firstPage?.total ?? 0;
+	const firstBatch = firstPage?.data?.stories?.length ?? 0;
+
+	// 3) If all stories fit in the first page, slice and return (preserve real total)
+	const cap = typeof limit === 'number' ? Math.min(limit, total) : total;
+	if (cap <= firstBatch) {
+		const sliced = (firstPage.data.stories || []).slice(0, cap);
+		return {
+			...firstPage,
+			data: { ...firstPage.data, stories: sliced },
+			total, // keep Storyblok's real total
+		} as ISbStories;
+	}
+
+	// 4) Remaining pages in parallel (cached per page) — loop-free
+	const maxPage = Math.ceil(cap / per_page);
+	const pageCount = Math.max(0, maxPage - pageStart);
+
+	const pagePromises: Array<Promise<ISbStories>> =
+		pageCount === 0
+			? []
+			: Array.from({ length: pageCount }, (_, idx) => {
+					const page = pageStart + 1 + idx;
+					const pageParams = { ...baseParams, page };
+					return storyblokApi.getStories(pageParams, {
+						next: {
+							revalidate: DEFAULT_REVALIDATE,
+						},
+					});
+				});
+
+	const otherPages = await Promise.all(pagePromises);
+
+	// 5) Combine and hard-cap to `limit` (preserve real total)
+	const combined = [
+		...(firstPage.data.stories || []),
+		...otherPages.flatMap(p => p.data.stories || []),
+	].slice(0, cap);
+
+	return {
+		...firstPage,
+		data: { ...firstPage.data, stories: combined },
+		total, // keep Storyblok's real total
+	} as ISbStories;
+};

package/storyblok/storyblok-api/src/lib/storyblok/fetch/fetchStory.ts

@@ -0,0 +1,95 @@
+import { getStoryblokApi } from '@storyblok/react/rsc';
+import type { ISbStoryParams } from 'storyblok-js-client';
+
+import { isDraftEnabled } from '@/lib/utils';
+
+import { mergeResolveRelations } from '../mergedRelations';
+import type {
+	ICustomSbStoriesParams,
+	ICustomSbStoryData,
+	StoryblokServiceDefaults,
+} from '../types';
+import { globalResolveRelations } from './config';
+import { fetchBreadcrumbs } from './fetchBreadcrumbs';
+import { fetchCv } from './fetchCv';
+
+/**
+ * Fetches a single Storyblok story by slug, with optional config and draft mode.
+ * Uses cache version (cv) for published content and revalidate for Next.js caching.
+ *
+ * @param {Object} params - Parameters for fetching the story.
+ * @param {string} params.slug - The story slug to fetch.
+ * @param {Partial<ICustomSbStoriesParams>} [params.config] - Optional Storyblok API config (language, resolve_relations, etc).
+ * @param {StoryblokServiceDefaults['draftMode']} [params.draftMode] - Whether to fetch draft content.
+ * @param {boolean} [params.resolveRelations=true] - Whether to merge and resolve relations for the story.
+ * @param {number} [params.revalidate=300] - Next.js cache revalidate time (seconds).
+ * @returns {Promise<ICustomSbStoryData|null>} The story data with breadcrumbs, or null if not found or error.
+ */
+export const fetchStory = async ({
+	slug,
+	config,
+	draftMode,
+	resolveRelations = true,
+	revalidate = 300,
+}: {
+	slug: string;
+	config?: Partial<ICustomSbStoriesParams>;
+	draftMode?: StoryblokServiceDefaults['draftMode'];
+	resolveRelations?: boolean;
+	revalidate?: number;
+}): Promise<ICustomSbStoryData | null> => {
+	try {
+		const isDraft = isDraftEnabled(draftMode);
+		const cv = isDraft ? undefined : await fetchCv();
+
+		// Merge caller relations with global ones (for single story only)
+		const mergedRelations = mergeResolveRelations(
+			resolveRelations,
+			config?.resolve_relations,
+			globalResolveRelations
+		);
+
+		// Narrow to story params only (avoid leaking list params into getStory)
+		const resolveLinks =
+			(config?.resolve_links as
+				| 'url'
+				| 'story'
+				| '0'
+				| '1'
+				| 'link'
+				| undefined) ?? 'url';
+
+		const params: ISbStoryParams = {
+			version: isDraft ? 'draft' : 'published',
+			cv,
+			...(mergedRelations ? { resolve_relations: mergedRelations } : {}),
+			resolve_links: resolveLinks,
+			...(config?.language ? { language: config.language } : {}),
+		};
+
+		const storyblokApi = getStoryblokApi();
+		const { data } = await storyblokApi.getStory(slug, params, {
+			next: {
+				revalidate,
+			},
+		});
+
+		const story = data?.story as ICustomSbStoryData | undefined;
+		if (!story) return null;
+
+		// Fetch breadcrumbs (already lightweight + typed)
+		const breadcrumbs = await fetchBreadcrumbs({
+			story,
+			draftMode: isDraft,
+		});
+
+		return {
+			...story,
+			breadcrumbs: breadcrumbs ?? [],
+		};
+	} catch (error) {
+		// biome-ignore lint/suspicious/noConsole: needs to log errors
+		console.error('Error fetching story:', error);
+		return null;
+	}
+};

package/storyblok/storyblok-api/src/lib/storyblok/helpers.ts

@@ -0,0 +1,111 @@
+import { decodeHTML } from 'entities';
+import type { ISbStoryData } from 'storyblok-js-client';
+import { render } from 'storyblok-rich-text-react-renderer';
+
+import type { DateFormat } from '@/lib/storyblok/types';
+
+import type {
+	StoryblokAsset,
+	StoryblokMultilink,
+	StoryblokRichtext,
+} from '.storyblok/types/storyblok';
+
+export const getSlugFromParams = <T extends string[] | string>(slug?: T) => {
+	const path = (slug && Array.isArray(slug) && slug.join('/')) || 'home';
+
+	return path;
+};
+
+export const isSbAssetEmpty = (asset: StoryblokAsset | undefined) => {
+	if (!asset) return false;
+
+	return asset.filename === '' || asset.filename === null;
+};
+
+export const sbText = (richtext: StoryblokRichtext | undefined): string => {
+	if (!richtext) return '';
+
+	return (
+		richtext &&
+		render(richtext, {
+			textResolver: text => decodeHTML(text),
+		})
+	);
+};
+
+export const getSbUrl = (link: StoryblokMultilink | undefined): string => {
+	if (!link) return '';
+
+	if (!link.url && !link.cached_url) return '';
+
+	const anchorID = link.anchor ? `#${link.anchor}` : '';
+	const href = link?.url || `/${link?.cached_url}`;
+
+	return anchorID || href;
+};
+
+export const checkSbRelations = (items: unknown[]): ISbStoryData[] => {
+	return items.filter(
+		(item): item is ISbStoryData =>
+			typeof item === 'object' &&
+			item !== null &&
+			'id' in item &&
+			'name' in item
+	);
+};
+
+export function formatSbDate(input: string, style: DateFormat) {
+	const date = new Date(input.replace(' ', 'T'));
+
+	const fullMonthNames = [
+		'January',
+		'February',
+		'March',
+		'April',
+		'May',
+		'June',
+		'July',
+		'August',
+		'September',
+		'October',
+		'November',
+		'December',
+	];
+
+	const getDaySuffix = (day: number) => {
+		if (day >= 11 && day <= 13) return 'th';
+		switch (day % 10) {
+			case 1:
+				return 'st';
+			case 2:
+				return 'nd';
+			case 3:
+				return 'rd';
+			default:
+				return 'th';
+		}
+	};
+
+	const day = date.getDate();
+	const monthIndex = date.getMonth();
+	const year = date.getFullYear();
+
+	const month =
+		style === 'monthDay'
+			? (fullMonthNames[monthIndex]?.slice(0, 3) ?? '')
+			: (fullMonthNames[monthIndex] ?? '');
+
+	switch (style) {
+		case 'monthDay':
+			// e.g., "Aug 25"
+			return `${month} ${day}`;
+		case 'monthYear':
+			// e.g., "August 2003"
+			return `${month} ${year}`;
+		case 'dayMonthYear':
+			// e.g., "25th August, 2003"
+			return `${day}${getDaySuffix(day)} ${month}, ${year}`;
+		default:
+			return date.toDateString(); // fallback
+	}
+}

package/storyblok/storyblok-api/src/lib/storyblok/index.ts

@@ -0,0 +1,16 @@
+import { apiPlugin, storyblokInit } from '@storyblok/react/rsc';
+
+import StoryblokFallback from '@/ui/FallbackComponent';
+
+import { bloks } from './bloks';
+
+export const getStoryblokApi = storyblokInit({
+	accessToken: process.env.STORYBLOK_PREVIEW_TOKEN,
+	use: [apiPlugin],
+	components: bloks,
+	apiOptions: {
+		region: 'eu',
+	},
+	enableFallbackComponent: true,
+	customFallbackComponent: StoryblokFallback,
+});