@contractspec/bundle.marketing 3.8.8 → 3.8.10

package/src/components/templates/template-catalog.ts

@@ -0,0 +1,140 @@
+import type {
+	ExampleKind,
+	ExampleSandboxMode,
+	ExampleSpec,
+} from '@contractspec/lib.contracts-spec/examples/types';
+import type { Stability } from '@contractspec/lib.contracts-spec/ownership';
+import type {
+	TemplateDefinition,
+	TemplateId,
+} from '@contractspec/lib.example-shared-ui';
+import { listExamples, listTemplates } from '@contractspec/module.examples';
+import { isNewTemplateId, NEW_TEMPLATE_IDS } from './template-new';
+
+export interface LocalTemplateCatalogItem {
+	id: TemplateId;
+	title: string;
+	description: string;
+	tags: string[];
+	kind: ExampleKind;
+	stability: Stability;
+	previewUrl: string;
+	featureList: string[];
+	sandboxModes: readonly ExampleSandboxMode[];
+	renderTargets: string[];
+	isNew: boolean;
+	packageName: string;
+}
+
+interface TemplateFilterCandidate {
+	title: string;
+	description: string;
+	tags: readonly string[];
+}
+
+const NEW_TEMPLATE_INDEX = new Map<string, number>(
+	NEW_TEMPLATE_IDS.map((templateId, index) => [templateId, index] as const)
+);
+
+export function buildLocalTemplateCatalog(
+	examples: readonly ExampleSpec[] = listExamples(),
+	templates: readonly TemplateDefinition[] = listTemplates()
+): LocalTemplateCatalogItem[] {
+	const templatesById = new Map(
+		templates.map((template) => [template.id, template])
+	);
+
+	return examples
+		.filter(
+			(example) =>
+				example.meta.visibility === 'public' && example.surfaces.templates
+		)
+		.map((example) => {
+			const template = templatesById.get(example.meta.key);
+			const tags = Array.from(
+				new Set(example.meta.tags.map((tag) => tag.trim()).filter(Boolean))
+			).sort((left, right) => left.localeCompare(right));
+
+			return {
+				id: example.meta.key,
+				title: example.meta.title ?? template?.name ?? example.meta.key,
+				description: example.meta.summary ?? example.meta.description,
+				tags,
+				kind: example.meta.kind,
+				stability: example.meta.stability,
+				previewUrl:
+					template?.preview?.demoUrl ??
+					`/sandbox?template=${encodeURIComponent(example.meta.key)}`,
+				featureList: [...(template?.features ?? [])],
+				sandboxModes: example.surfaces.sandbox.modes,
+				renderTargets: [...(template?.renderTargets ?? [])],
+				isNew: isNewTemplateId(example.meta.key),
+				packageName: example.entrypoints.packageName,
+			};
+		})
+		.sort(compareLocalTemplateCatalogItems);
+}
+
+export function matchesTemplateFilters(
+	template: TemplateFilterCandidate,
+	search: string,
+	selectedTag: string | null
+): boolean {
+	return (
+		matchesTemplateSearch(template, search) &&
+		(selectedTag === null || template.tags.includes(selectedTag))
+	);
+}
+
+export function matchesTemplateSearch(
+	template: TemplateFilterCandidate,
+	search: string
+): boolean {
+	const haystack = [
+		template.title,
+		template.description,
+		template.tags.join(' '),
+	]
+		.join(' ')
+		.toLowerCase();
+	const searchTokens = search.trim().toLowerCase().split(/\s+/).filter(Boolean);
+
+	return (
+		searchTokens.length === 0 ||
+		searchTokens.every((token) => haystack.includes(token))
+	);
+}
+
+export function formatExampleKindLabel(kind: ExampleKind): string {
+	return kind
+		.split('-')
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(' ');
+}
+
+export function formatStabilityLabel(stability: Stability): string {
+	return stability
+		.split('_')
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(' ');
+}
+
+function compareLocalTemplateCatalogItems(
+	left: LocalTemplateCatalogItem,
+	right: LocalTemplateCatalogItem
+): number {
+	const leftNewIndex = NEW_TEMPLATE_INDEX.get(left.id);
+	const rightNewIndex = NEW_TEMPLATE_INDEX.get(right.id);
+
+	if (leftNewIndex !== undefined || rightNewIndex !== undefined) {
+		if (leftNewIndex === undefined) {
+			return 1;
+		}
+		if (rightNewIndex === undefined) {
+			return -1;
+		}
+		return leftNewIndex - rightNewIndex;
+	}
+
+	return left.title.localeCompare(right.title);
+}

package/src/components/templates/template-filters.ts

@@ -0,0 +1,57 @@
+import { matchesTemplateSearch } from './template-catalog';
+import type { TemplateTagFacet } from './template-tag-visibility';
+
+export interface TemplateFilterCandidate {
+	title: string;
+	description: string;
+	tags: readonly string[];
+}
+
+export interface TemplateFilterState<TTemplate> {
+	searchScopedTemplates: TTemplate[];
+	finalTemplates: TTemplate[];
+	tagFacets: TemplateTagFacet[];
+}
+
+export function buildTemplateFilterState<TTemplate>(
+	templates: readonly TTemplate[],
+	search: string,
+	selectedTag: string | null,
+	getCandidate: (template: TTemplate) => TemplateFilterCandidate
+): TemplateFilterState<TTemplate> {
+	const searchScopedTemplates = templates.filter((template) =>
+		matchesTemplateSearch(getCandidate(template), search)
+	);
+	const finalTemplates =
+		selectedTag === null
+			? searchScopedTemplates
+			: searchScopedTemplates.filter((template) =>
+					getCandidate(template).tags.includes(selectedTag)
+				);
+
+	return {
+		searchScopedTemplates,
+		finalTemplates,
+		tagFacets: buildTemplateTagFacets(searchScopedTemplates, getCandidate),
+	};
+}
+
+function buildTemplateTagFacets<TTemplate>(
+	templates: readonly TTemplate[],
+	getCandidate: (template: TTemplate) => TemplateFilterCandidate
+): TemplateTagFacet[] {
+	const counts = new Map<string, number>();
+
+	for (const template of templates) {
+		for (const tag of new Set(getCandidate(template).tags)) {
+			counts.set(tag, (counts.get(tag) ?? 0) + 1);
+		}
+	}
+
+	return [...counts.entries()]
+		.map(([tag, count]) => ({ tag, count }))
+		.sort(
+			(left, right) =>
+				right.count - left.count || left.tag.localeCompare(right.tag)
+		);
+}

package/src/components/templates/template-new.ts

@@ -0,0 +1,12 @@
+export const NEW_TEMPLATE_IDS = [
+	'minimal',
+	'messaging-agent-actions',
+	'policy-safe-knowledge-assistant',
+	'visualization-showcase',
+] as const;
+
+const NEW_TEMPLATE_ID_SET = new Set<string>(NEW_TEMPLATE_IDS);
+
+export function isNewTemplateId(templateId: string): boolean {
+	return NEW_TEMPLATE_ID_SET.has(templateId);
+}

package/src/components/templates/template-preview.ts

@@ -0,0 +1,57 @@
+import type {
+	RegistryTemplate,
+	TemplateId,
+} from '@contractspec/lib.example-shared-ui';
+import type { LocalTemplateCatalogItem } from './template-catalog';
+
+export type TemplatePreviewAction =
+	| { kind: 'modal'; templateId: TemplateId }
+	| { kind: 'sandbox'; href: string }
+	| { kind: 'disabled' };
+
+export type LocalTemplatePreviewAction = Exclude<
+	TemplatePreviewAction,
+	{ kind: 'disabled' }
+>;
+
+export const INLINE_TEMPLATE_PREVIEW_IDS = [
+	'agent-console',
+	'ai-chat-assistant',
+	'analytics-dashboard',
+	'crm-pipeline',
+	'data-grid-showcase',
+	'integration-hub',
+	'marketplace',
+	'saas-boilerplate',
+	'visualization-showcase',
+	'workflow-system',
+] as const;
+
+const INLINE_TEMPLATE_PREVIEW_SET = new Set<string>(
+	INLINE_TEMPLATE_PREVIEW_IDS
+);
+
+export function supportsInlineTemplatePreview(templateId: TemplateId): boolean {
+	return INLINE_TEMPLATE_PREVIEW_SET.has(templateId);
+}
+
+export function getLocalTemplatePreviewAction(
+	template: LocalTemplateCatalogItem
+): LocalTemplatePreviewAction {
+	if (supportsInlineTemplatePreview(template.id)) {
+		return { kind: 'modal', templateId: template.id };
+	}
+
+	return { kind: 'sandbox', href: template.previewUrl };
+}
+
+export function getRegistryTemplatePreviewAction(
+	template: RegistryTemplate,
+	localTemplate?: LocalTemplateCatalogItem
+): TemplatePreviewAction {
+	if (!localTemplate) {
+		return { kind: 'disabled' };
+	}
+
+	return getLocalTemplatePreviewAction(localTemplate);
+}

package/src/components/templates/template-source.ts

@@ -0,0 +1,13 @@
+export type TemplateSource = 'local' | 'registry';
+
+export function isRegistryConfigured(
+	registryUrl: string | null | undefined
+): boolean {
+	return Boolean(registryUrl?.trim());
+}
+
+export function getAvailableTemplateSources(
+	registryUrl: string | null | undefined
+): readonly TemplateSource[] {
+	return isRegistryConfigured(registryUrl) ? ['local', 'registry'] : ['local'];
+}

package/src/components/templates/template-tag-visibility.ts

@@ -0,0 +1,58 @@
+export const DEFAULT_VISIBLE_TEMPLATE_TAGS = 10;
+
+export interface TemplateTagFacet {
+	tag: string;
+	count: number;
+}
+
+export interface VisibleTemplateTagFacets {
+	visibleTagFacets: TemplateTagFacet[];
+	hiddenTagFacets: TemplateTagFacet[];
+}
+
+export function getVisibleTemplateTagFacets(
+	tagFacets: readonly TemplateTagFacet[],
+	selectedTag: string | null,
+	expanded: boolean,
+	visibleCount = DEFAULT_VISIBLE_TEMPLATE_TAGS
+): VisibleTemplateTagFacets {
+	if (expanded) {
+		return {
+			visibleTagFacets: pinSelectedTagFacet(tagFacets, selectedTag),
+			hiddenTagFacets: [],
+		};
+	}
+
+	const visibleTagFacets = pinSelectedTagFacet(
+		tagFacets.slice(0, visibleCount),
+		selectedTag,
+		tagFacets
+	);
+	const visibleTags = new Set(visibleTagFacets.map((facet) => facet.tag));
+
+	return {
+		visibleTagFacets,
+		hiddenTagFacets: tagFacets.filter((facet) => !visibleTags.has(facet.tag)),
+	};
+}
+
+function pinSelectedTagFacet(
+	tagFacets: readonly TemplateTagFacet[],
+	selectedTag: string | null,
+	fallbackTagFacets: readonly TemplateTagFacet[] = tagFacets
+): TemplateTagFacet[] {
+	if (
+		selectedTag === null ||
+		tagFacets.some((facet) => facet.tag === selectedTag)
+	) {
+		return [...tagFacets];
+	}
+
+	return [
+		...tagFacets,
+		fallbackTagFacets.find((facet) => facet.tag === selectedTag) ?? {
+			tag: selectedTag,
+			count: 0,
+		},
+	];
+}

package/src/components/templates/useTemplateBrowseState.ts

@@ -0,0 +1,101 @@
+'use client';
+
+import { useRegistryTemplates } from '@contractspec/lib.example-shared-ui';
+import { useEffect, useMemo, useState } from 'react';
+import { buildLocalTemplateCatalog } from './template-catalog';
+import { buildTemplateFilterState } from './template-filters';
+import {
+	getAvailableTemplateSources,
+	isRegistryConfigured,
+	type TemplateSource,
+} from './template-source';
+import { getVisibleTemplateTagFacets } from './template-tag-visibility';
+
+const REGISTRY_URL = process.env.NEXT_PUBLIC_CONTRACTSPEC_REGISTRY_URL;
+
+export function useTemplateBrowseState() {
+	const [selectedTag, setSelectedTag] = useState<string | null>(null);
+	const [search, setSearch] = useState('');
+	const [source, setSource] = useState<TemplateSource>('local');
+	const [showAllTags, setShowAllTags] = useState(false);
+	const registryConfigured = isRegistryConfigured(REGISTRY_URL);
+	const availableSources = getAvailableTemplateSources(REGISTRY_URL);
+	const localTemplates = useMemo(() => buildLocalTemplateCatalog(), []);
+	const localTemplateById = useMemo(
+		() => new Map(localTemplates.map((template) => [template.id, template])),
+		[localTemplates]
+	);
+	const { data: registryTemplates = [], isLoading: registryLoading } =
+		useRegistryTemplates();
+	const localFilterState = useMemo(
+		() =>
+			buildTemplateFilterState(
+				localTemplates,
+				search,
+				selectedTag,
+				(template) => ({
+					title: template.title,
+					description: template.description,
+					tags: template.tags,
+				})
+			),
+		[localTemplates, search, selectedTag]
+	);
+	const registryFilterState = useMemo(
+		() =>
+			buildTemplateFilterState(
+				registryTemplates,
+				search,
+				selectedTag,
+				(template) => ({
+					title: template.name,
+					description: template.description,
+					tags: template.tags,
+				})
+			),
+		[registryTemplates, search, selectedTag]
+	);
+	const activeFilterState =
+		source === 'registry' ? registryFilterState : localFilterState;
+	const suppressTagRail =
+		source === 'registry' &&
+		(registryLoading || registryTemplates.length === 0);
+	const { visibleTagFacets, hiddenTagFacets } = useMemo(
+		() =>
+			getVisibleTemplateTagFacets(
+				activeFilterState.tagFacets,
+				selectedTag,
+				showAllTags
+			),
+		[activeFilterState.tagFacets, selectedTag, showAllTags]
+	);
+	const showTagFilters =
+		!suppressTagRail &&
+		(visibleTagFacets.length > 0 || hiddenTagFacets.length > 0);
+
+	useEffect(() => {
+		setShowAllTags(false);
+	}, [search, showTagFilters, source]);
+
+	return {
+		selectedTag,
+		setSelectedTag,
+		search,
+		setSearch,
+		source,
+		setSource,
+		showAllTags,
+		setShowAllTags,
+		registryConfigured,
+		availableSources,
+		localTemplates,
+		localTemplateById,
+		registryTemplates,
+		registryLoading,
+		localFilterState,
+		registryFilterState,
+		visibleTagFacets,
+		hiddenTagFacets,
+		showTagFilters,
+	};
+}

package/.turbo/turbo-prebuild.log

@@ -1 +0,0 @@
-$ contractspec-bun-build prebuild