@contractspec/bundle.library 3.7.5 → 3.7.7

package/src/presentation/features/hooks/useFeatureFilters.ts

@@ -1,39 +1,39 @@
 'use client';
 
-import { useState, useMemo, useCallback } from 'react';
 import type { FeatureModuleSpec } from '@contractspec/lib.contracts-spec/features';
+import { useCallback, useMemo, useState } from 'react';
 
 export interface FeatureFilters {
-  search: string;
-  tags: string[];
-  stability: string[];
-  domain: string[];
+	search: string;
+	tags: string[];
+	stability: string[];
+	domain: string[];
 }
 
 export interface UseFeatureFiltersReturn {
-  /** Current filter state. */
-  filters: FeatureFilters;
-  /** Update the search query. */
-  setSearch: (search: string) => void;
-  /** Toggle a tag filter. */
-  toggleTag: (tag: string) => void;
-  /** Toggle a stability filter. */
-  toggleStability: (stability: string) => void;
-  /** Toggle a domain filter. */
-  toggleDomain: (domain: string) => void;
-  /** Clear all filters. */
-  clearFilters: () => void;
-  /** Filtered features based on current filters. */
-  filteredFeatures: FeatureModuleSpec[];
-  /** Whether any filters are active. */
-  hasActiveFilters: boolean;
+	/** Current filter state. */
+	filters: FeatureFilters;
+	/** Update the search query. */
+	setSearch: (search: string) => void;
+	/** Toggle a tag filter. */
+	toggleTag: (tag: string) => void;
+	/** Toggle a stability filter. */
+	toggleStability: (stability: string) => void;
+	/** Toggle a domain filter. */
+	toggleDomain: (domain: string) => void;
+	/** Clear all filters. */
+	clearFilters: () => void;
+	/** Filtered features based on current filters. */
+	filteredFeatures: FeatureModuleSpec[];
+	/** Whether any filters are active. */
+	hasActiveFilters: boolean;
 }
 
 const defaultFilters: FeatureFilters = {
-  search: '',
-  tags: [],
-  stability: [],
-  domain: [],
+	search: '',
+	tags: [],
+	stability: [],
+	domain: [],
 };
 
 /**
@@ -41,97 +41,97 @@ const defaultFilters: FeatureFilters = {
  * Provides filter controls and filtered feature list.
  */
 export function useFeatureFilters(
-  features: FeatureModuleSpec[]
+	features: FeatureModuleSpec[]
 ): UseFeatureFiltersReturn {
-  const [filters, setFilters] = useState<FeatureFilters>(defaultFilters);
-
-  const setSearch = useCallback((search: string) => {
-    setFilters((prev) => ({ ...prev, search }));
-  }, []);
-
-  const toggleTag = useCallback((tag: string) => {
-    setFilters((prev) => ({
-      ...prev,
-      tags: prev.tags.includes(tag)
-        ? prev.tags.filter((t) => t !== tag)
-        : [...prev.tags, tag],
-    }));
-  }, []);
-
-  const toggleStability = useCallback((stability: string) => {
-    setFilters((prev) => ({
-      ...prev,
-      stability: prev.stability.includes(stability)
-        ? prev.stability.filter((s) => s !== stability)
-        : [...prev.stability, stability],
-    }));
-  }, []);
-
-  const toggleDomain = useCallback((domain: string) => {
-    setFilters((prev) => ({
-      ...prev,
-      domain: prev.domain.includes(domain)
-        ? prev.domain.filter((d) => d !== domain)
-        : [...prev.domain, domain],
-    }));
-  }, []);
-
-  const clearFilters = useCallback(() => setFilters(defaultFilters), []);
-
-  const hasActiveFilters = useMemo(() => {
-    return (
-      filters.search.length > 0 ||
-      filters.tags.length > 0 ||
-      filters.stability.length > 0 ||
-      filters.domain.length > 0
-    );
-  }, [filters]);
-
-  const filteredFeatures = useMemo(() => {
-    return features.filter((feature) => {
-      // Search filter
-      if (filters.search) {
-        const searchLower = filters.search.toLowerCase();
-        const title = feature.meta.title ?? '';
-        const matches =
-          title.toLowerCase().includes(searchLower) ||
-          feature.meta.description?.toLowerCase().includes(searchLower) ||
-          feature.meta.key.toLowerCase().includes(searchLower);
-        if (!matches) return false;
-      }
-
-      // Tag filter
-      if (filters.tags.length > 0) {
-        const hasTag = filters.tags.some((tag) =>
-          feature.meta.tags?.includes(tag)
-        );
-        if (!hasTag) return false;
-      }
-
-      // Stability filter
-      if (filters.stability.length > 0) {
-        if (!filters.stability.includes(feature.meta.stability ?? 'unknown'))
-          return false;
-      }
-
-      // Domain filter
-      if (filters.domain.length > 0) {
-        if (!filters.domain.includes(feature.meta.domain ?? 'unknown'))
-          return false;
-      }
-
-      return true;
-    });
-  }, [features, filters]);
-
-  return {
-    filters,
-    setSearch,
-    toggleTag,
-    toggleStability,
-    toggleDomain,
-    clearFilters,
-    filteredFeatures,
-    hasActiveFilters,
-  };
+	const [filters, setFilters] = useState<FeatureFilters>(defaultFilters);
+
+	const setSearch = useCallback((search: string) => {
+		setFilters((prev) => ({ ...prev, search }));
+	}, []);
+
+	const toggleTag = useCallback((tag: string) => {
+		setFilters((prev) => ({
+			...prev,
+			tags: prev.tags.includes(tag)
+				? prev.tags.filter((t) => t !== tag)
+				: [...prev.tags, tag],
+		}));
+	}, []);
+
+	const toggleStability = useCallback((stability: string) => {
+		setFilters((prev) => ({
+			...prev,
+			stability: prev.stability.includes(stability)
+				? prev.stability.filter((s) => s !== stability)
+				: [...prev.stability, stability],
+		}));
+	}, []);
+
+	const toggleDomain = useCallback((domain: string) => {
+		setFilters((prev) => ({
+			...prev,
+			domain: prev.domain.includes(domain)
+				? prev.domain.filter((d) => d !== domain)
+				: [...prev.domain, domain],
+		}));
+	}, []);
+
+	const clearFilters = useCallback(() => setFilters(defaultFilters), []);
+
+	const hasActiveFilters = useMemo(() => {
+		return (
+			filters.search.length > 0 ||
+			filters.tags.length > 0 ||
+			filters.stability.length > 0 ||
+			filters.domain.length > 0
+		);
+	}, [filters]);
+
+	const filteredFeatures = useMemo(() => {
+		return features.filter((feature) => {
+			// Search filter
+			if (filters.search) {
+				const searchLower = filters.search.toLowerCase();
+				const title = feature.meta.title ?? '';
+				const matches =
+					title.toLowerCase().includes(searchLower) ||
+					feature.meta.description?.toLowerCase().includes(searchLower) ||
+					feature.meta.key.toLowerCase().includes(searchLower);
+				if (!matches) return false;
+			}
+
+			// Tag filter
+			if (filters.tags.length > 0) {
+				const hasTag = filters.tags.some((tag) =>
+					feature.meta.tags?.includes(tag)
+				);
+				if (!hasTag) return false;
+			}
+
+			// Stability filter
+			if (filters.stability.length > 0) {
+				if (!filters.stability.includes(feature.meta.stability ?? 'unknown'))
+					return false;
+			}
+
+			// Domain filter
+			if (filters.domain.length > 0) {
+				if (!filters.domain.includes(feature.meta.domain ?? 'unknown'))
+					return false;
+			}
+
+			return true;
+		});
+	}, [features, filters]);
+
+	return {
+		filters,
+		setSearch,
+		toggleTag,
+		toggleStability,
+		toggleDomain,
+		clearFilters,
+		filteredFeatures,
+		hasActiveFilters,
+	};
 }

package/src/presentation/features/hooks/useFeatureRegistry.ts

@@ -1,24 +1,24 @@
 'use client';
 
-import { useMemo } from 'react';
 import type { FeatureModuleSpec } from '@contractspec/lib.contracts-spec/features';
+import { useMemo } from 'react';
 import { getContractSpecFeatureRegistry } from '../../../features/registry';
 
 export interface UseFeatureRegistryReturn {
-  /** All registered features. */
-  features: FeatureModuleSpec[];
-  /** Get a feature by its key. */
-  getFeature: (key: string) => FeatureModuleSpec | undefined;
-  /** Get features with a specific tag. */
-  getByTag: (tag: string) => FeatureModuleSpec[];
-  /** Get features by owner. */
-  getByOwner: (owner: string) => FeatureModuleSpec[];
-  /** Get all unique tags across features. */
-  getUniqueTags: () => string[];
-  /** Get all unique domains across features. */
-  getUniqueDomains: () => string[];
-  /** Get all unique stability values across features. */
-  getUniqueStabilities: () => string[];
+	/** All registered features. */
+	features: FeatureModuleSpec[];
+	/** Get a feature by its key. */
+	getFeature: (key: string) => FeatureModuleSpec | undefined;
+	/** Get features with a specific tag. */
+	getByTag: (tag: string) => FeatureModuleSpec[];
+	/** Get features by owner. */
+	getByOwner: (owner: string) => FeatureModuleSpec[];
+	/** Get all unique tags across features. */
+	getUniqueTags: () => string[];
+	/** Get all unique domains across features. */
+	getUniqueDomains: () => string[];
+	/** Get all unique stability values across features. */
+	getUniqueStabilities: () => string[];
 }
 
 /**
@@ -26,31 +26,31 @@ export interface UseFeatureRegistryReturn {
  * Provides feature listing and filtering capabilities.
  */
 export function useFeatureRegistry(): UseFeatureRegistryReturn {
-  const registry = useMemo(() => getContractSpecFeatureRegistry(), []);
+	const registry = useMemo(() => getContractSpecFeatureRegistry(), []);
 
-  return useMemo(() => {
-    const features = registry.list();
+	return useMemo(() => {
+		const features = registry.list();
 
-    return {
-      features,
-      getFeature: (key: string) => registry.get(key),
-      getByTag: (tag: string) => registry.listByTag(tag),
-      getByOwner: (owner: string) => registry.listByOwner(owner),
-      getUniqueTags: () => registry.getUniqueTags(),
-      getUniqueDomains: () => {
-        const domains = new Set<string>();
-        for (const f of features) {
-          if (f.meta.domain) domains.add(f.meta.domain);
-        }
-        return [...domains].sort();
-      },
-      getUniqueStabilities: () => {
-        const stabilities = new Set<string>();
-        for (const f of features) {
-          if (f.meta.stability) stabilities.add(f.meta.stability);
-        }
-        return [...stabilities].sort();
-      },
-    };
-  }, [registry]);
+		return {
+			features,
+			getFeature: (key: string) => registry.get(key),
+			getByTag: (tag: string) => registry.listByTag(tag),
+			getByOwner: (owner: string) => registry.listByOwner(owner),
+			getUniqueTags: () => registry.getUniqueTags(),
+			getUniqueDomains: () => {
+				const domains = new Set<string>();
+				for (const f of features) {
+					if (f.meta.domain) domains.add(f.meta.domain);
+				}
+				return [...domains].sort();
+			},
+			getUniqueStabilities: () => {
+				const stabilities = new Set<string>();
+				for (const f of features) {
+					if (f.meta.stability) stabilities.add(f.meta.stability);
+				}
+				return [...stabilities].sort();
+			},
+		};
+	}, [registry]);
 }

package/src/presentation/features/hooks/useRelatedDocs.ts

@@ -1,40 +1,40 @@
 'use client';
 
-import { useMemo } from 'react';
 import { defaultDocRegistry } from '@contractspec/lib.contracts-spec/docs';
+import { useMemo } from 'react';
 
 /**
  * Hook to fetch documentation blocks related to a specific key or set of tags.
  */
 export function useRelatedDocs(key: string, tags?: string[]) {
-  const docs = useMemo(() => {
-    try {
-      const allDocs = defaultDocRegistry.list();
-      return allDocs
-        .filter(({ block }) => {
-          // Match by key in ID or title
-          const keyMatch =
-            block.id.toLowerCase().includes(key.toLowerCase()) ||
-            block.title.toLowerCase().includes(key.toLowerCase());
+	const docs = useMemo(() => {
+		try {
+			const allDocs = defaultDocRegistry.list();
+			return allDocs
+				.filter(({ block }) => {
+					// Match by key in ID or title
+					const keyMatch =
+						block.id.toLowerCase().includes(key.toLowerCase()) ||
+						block.title.toLowerCase().includes(key.toLowerCase());
 
-          // Match by tags
-          const tagMatch = tags?.some((t) =>
-            block.tags?.some((bt) => bt.toLowerCase().includes(t.toLowerCase()))
-          );
+					// Match by tags
+					const tagMatch = tags?.some((t) =>
+						block.tags?.some((bt) => bt.toLowerCase().includes(t.toLowerCase()))
+					);
 
-          return keyMatch || tagMatch;
-        })
-        .map(({ block, route }) => ({
-          id: block.id,
-          title: block.title,
-          summary: block.summary,
-          route,
-        }));
-    } catch (e) {
-      console.error('Failed to fetch related docs:', e);
-      return [];
-    }
-  }, [key, tags]);
+					return keyMatch || tagMatch;
+				})
+				.map(({ block, route }) => ({
+					id: block.id,
+					title: block.title,
+					summary: block.summary,
+					route,
+				}));
+		} catch (e) {
+			console.error('Failed to fetch related docs:', e);
+			return [];
+		}
+	}, [key, tags]);
 
-  return docs;
+	return docs;
 }

package/src/presentation/features/index.ts

@@ -1,82 +1,80 @@
 // Atoms
 export {
-  FeatureIcon,
-  getFeatureIconTone,
-  type FeatureIconProps,
+	FeatureIcon,
+	type FeatureIconProps,
+	getFeatureIconTone,
 } from './atoms/FeatureIcon';
 
 // Hooks
 export {
-  useFeatureRegistry,
-  type UseFeatureRegistryReturn,
-  useFeatureFilters,
-  type UseFeatureFiltersReturn,
-  type FeatureFilters,
-  useContractsRegistry,
-  type UseContractsRegistryReturn,
+	type FeatureFilters,
+	type UseContractsRegistryReturn,
+	type UseFeatureFiltersReturn,
+	type UseFeatureRegistryReturn,
+	useContractsRegistry,
+	useFeatureFilters,
+	useFeatureRegistry,
 } from './hooks';
 export { useRelatedDocs } from './hooks/useRelatedDocs';
 
 // Molecules
 export { FeatureCard, type FeatureCardProps } from './molecules/FeatureCard';
 export {
-  FeatureFiltersBar,
-  type FeatureFiltersBarProps,
+	FeatureCategoryHeader,
+	type FeatureCategoryHeaderProps,
+} from './molecules/FeatureCategoryHeader';
+export {
+	FeatureFiltersBar,
+	type FeatureFiltersBarProps,
 } from './molecules/FeatureFilters';
 export {
-  FeatureHoverPreview,
-  type FeatureHoverPreviewProps,
+	FeatureHoverPreview,
+	type FeatureHoverPreviewProps,
 } from './molecules/FeatureHoverPreview';
+export { FeatureDataViewsList } from './organisms/FeatureDataViewsList';
 export {
-  FeatureCategoryHeader,
-  type FeatureCategoryHeaderProps,
-} from './molecules/FeatureCategoryHeader';
-
+	FeatureDetail,
+	type FeatureDetailProps,
+} from './organisms/FeatureDetail';
 // Organisms
 export {
-  FeatureDiscovery,
-  type FeatureDiscoveryProps,
-  type FeatureViewMode,
-  type FeatureGroupBy,
+	FeatureDiscovery,
+	type FeatureDiscoveryProps,
+	type FeatureGroupBy,
+	type FeatureViewMode,
 } from './organisms/FeatureDiscovery';
-export {
-  FeatureDetail,
-  type FeatureDetailProps,
-} from './organisms/FeatureDetail';
-export { FeatureOperationsList } from './organisms/FeatureOperationsList';
 export { FeatureEventsList } from './organisms/FeatureEventsList';
-export { FeaturePresentationsList } from './organisms/FeaturePresentationsList';
-export { FeatureDataViewsList } from './organisms/FeatureDataViewsList';
 export { FeatureFormsList } from './organisms/FeatureFormsList';
-
-// Templates
+export { FeatureOperationsList } from './organisms/FeatureOperationsList';
+export { FeaturePresentationsList } from './organisms/FeaturePresentationsList';
 export {
-  FeatureOverviewTemplate,
-  type FeatureOverviewTemplateProps,
-} from './templates/FeatureOverviewTemplate';
-export { FeatureOperationsTemplate } from './templates/FeatureOperationsTemplate';
-export { FeatureEventsTemplate } from './templates/FeatureEventsTemplate';
-export { FeaturePresentationsTemplate } from './templates/FeaturePresentationsTemplate';
+	FeatureDataViewDetailTemplate,
+	type FeatureDataViewDetailTemplateProps,
+} from './templates/FeatureDataViewDetailTemplate';
 export { FeatureDataViewsTemplate } from './templates/FeatureDataViewsTemplate';
+export {
+	FeatureEventDetailTemplate,
+	type FeatureEventDetailTemplateProps,
+} from './templates/FeatureEventDetailTemplate';
+export { FeatureEventsTemplate } from './templates/FeatureEventsTemplate';
+export {
+	FeatureFormDetailTemplate,
+	type FeatureFormDetailTemplateProps,
+} from './templates/FeatureFormDetailTemplate';
 export { FeatureFormsTemplate } from './templates/FeatureFormsTemplate';
 export {
-  FeatureOperationDetailTemplate,
-  type FeatureOperationDetailTemplateProps,
+	FeatureOperationDetailTemplate,
+	type FeatureOperationDetailTemplateProps,
 } from './templates/FeatureOperationDetailTemplate';
+export { FeatureOperationsTemplate } from './templates/FeatureOperationsTemplate';
+// Templates
 export {
-  FeatureEventDetailTemplate,
-  type FeatureEventDetailTemplateProps,
-} from './templates/FeatureEventDetailTemplate';
+	FeatureOverviewTemplate,
+	type FeatureOverviewTemplateProps,
+} from './templates/FeatureOverviewTemplate';
 export {
-  FeaturePresentationDetailTemplate,
-  type FeaturePresentationDetailTemplateProps,
+	FeaturePresentationDetailTemplate,
+	type FeaturePresentationDetailTemplateProps,
 } from './templates/FeaturePresentationDetailTemplate';
-export {
-  FeatureDataViewDetailTemplate,
-  type FeatureDataViewDetailTemplateProps,
-} from './templates/FeatureDataViewDetailTemplate';
-export {
-  FeatureFormDetailTemplate,
-  type FeatureFormDetailTemplateProps,
-} from './templates/FeatureFormDetailTemplate';
+export { FeaturePresentationsTemplate } from './templates/FeaturePresentationsTemplate';
 export type { FeatureListTemplateProps } from './templates/types';