@autumnsgrove/groveengine 0.8.5 → 0.9.0

package/dist/ui/components/forms/filterUtils.js

@@ -0,0 +1,240 @@
+/**
+ * Common filter utilities for use with ContentSearch component
+ * Part of the Grove UI design system
+ *
+ * @example
+ * ```typescript
+ * import { createTextFilter, createMultiFieldFilter } from '@autumnsgrove/groveengine';
+ *
+ * const filterPost = createTextFilter(['title', 'description']);
+ * <ContentSearch items={posts} filterFn={filterPost} />
+ * ```
+ */
+/**
+ * Normalize text for searching (lowercase, trim)
+ */
+export function normalizeSearchText(text) {
+    return text.toLowerCase().trim();
+}
+/**
+ * Check if normalized text includes a normalized query
+ * Note: Both inputs should already be normalized via normalizeSearchText()
+ *
+ * @param normalizedText - Already normalized text to search in
+ * @param normalizedQuery - Already normalized query to search for
+ */
+export function includesNormalized(normalizedText, normalizedQuery) {
+    return normalizedText.includes(normalizedQuery);
+}
+/**
+ * Check if text includes a search query (case-insensitive)
+ * This is a convenience function that normalizes both inputs
+ *
+ * @param text - Text to search in (will be normalized)
+ * @param query - Query to search for (will be normalized)
+ */
+export function textIncludes(text, query) {
+    return normalizeSearchText(text).includes(normalizeSearchText(query));
+}
+/**
+ * Create a filter function that searches multiple text fields
+ *
+ * @param fields - Array of field names to search
+ * @returns Filter function for use with ContentSearch
+ *
+ * @example
+ * ```typescript
+ * const filterPost = createTextFilter(['title', 'description', 'author']);
+ * <ContentSearch items={posts} filterFn={filterPost} />
+ * ```
+ */
+export function createTextFilter(fields) {
+    return (item, query) => {
+        const normalizedQuery = normalizeSearchText(query);
+        return fields.some(field => {
+            const value = item[field];
+            if (typeof value === 'string') {
+                // Use includesNormalized to avoid double normalization
+                return includesNormalized(normalizeSearchText(value), normalizedQuery);
+            }
+            return false;
+        });
+    };
+}
+/**
+ * Create a filter function that searches text fields and array fields (like tags)
+ *
+ * @param textFields - Array of text field names to search
+ * @param arrayFields - Array of array field names to search (e.g., tags)
+ * @returns Filter function for use with ContentSearch
+ *
+ * @example
+ * ```typescript
+ * const filterPost = createMultiFieldFilter(['title', 'description'], ['tags', 'categories']);
+ * <ContentSearch items={posts} filterFn={filterPost} />
+ * ```
+ */
+export function createMultiFieldFilter(textFields, arrayFields = []) {
+    return (item, query) => {
+        const normalizedQuery = normalizeSearchText(query);
+        // Check text fields
+        const matchesText = textFields.some(field => {
+            const value = item[field];
+            if (typeof value === 'string') {
+                // Use includesNormalized to avoid double normalization
+                return includesNormalized(normalizeSearchText(value), normalizedQuery);
+            }
+            return false;
+        });
+        if (matchesText)
+            return true;
+        // Check array fields
+        const matchesArray = arrayFields.some(field => {
+            const value = item[field];
+            if (Array.isArray(value)) {
+                return value.some(element => {
+                    if (typeof element === 'string') {
+                        // Use includesNormalized to avoid double normalization
+                        return includesNormalized(normalizeSearchText(element), normalizedQuery);
+                    }
+                    return false;
+                });
+            }
+            return false;
+        });
+        return matchesArray;
+    };
+}
+/**
+ * Pre-compute lowercase versions of searchable fields for performance
+ *
+ * **When to use this optimization:**
+ * - **Large datasets (100+ items)**: Repeated toLowerCase() calls during filtering become expensive
+ * - **Frequent searches**: Users actively searching/filtering the same dataset multiple times
+ * - **Multiple searchable fields**: More fields = more normalization = more performance gain
+ * - **Real-time filtering**: When debouncing isn't enough and you need instant results
+ *
+ * **When NOT to use:**
+ * - Small datasets (<50 items): Minimal performance benefit, adds memory overhead
+ * - Static lists that don't change: Consider precomputing at build time instead
+ * - Infrequent searches: The setup cost may outweigh the benefit
+ *
+ * @param items - Array of items to optimize
+ * @param fields - Fields to pre-compute lowercase versions of
+ * @returns Array of items with lowercase fields added (suffixed with 'Lower')
+ *
+ * @example
+ * ```typescript
+ * // In your Svelte component with large dataset (100+ posts)
+ * let postsWithLowercase = $derived.by(() => {
+ *   return precomputeLowercaseFields(posts, ['title', 'description', 'tags']);
+ * });
+ * // Creates: { ...post, titleLower: '...', descriptionLower: '...', tagsLower: [...] }
+ *
+ * function filterPost(post, query) {
+ *   const q = query.toLowerCase();
+ *   return post.titleLower.includes(q) ||
+ *          post.descriptionLower.includes(q) ||
+ *          post.tagsLower.some(tag => tag.includes(q));
+ * }
+ *
+ * <ContentSearch items={postsWithLowercase} filterFn={filterPost} />
+ * ```
+ */
+export function precomputeLowercaseFields(items, fields) {
+    return items.map(item => {
+        const computed = { ...item };
+        fields.forEach(field => {
+            const value = item[field];
+            if (typeof value === 'string') {
+                computed[`${String(field)}Lower`] = value.toLowerCase();
+            }
+            else if (Array.isArray(value)) {
+                computed[`${String(field)}Lower`] = value.map(v => typeof v === 'string' ? v.toLowerCase() : v);
+            }
+        });
+        return computed;
+    });
+}
+/**
+ * Create a fuzzy filter that matches partial words
+ *
+ * @param fields - Array of field names to search
+ * @param minMatchLength - Minimum length of query before fuzzy matching (default: 2)
+ * @returns Filter function for use with ContentSearch
+ *
+ * @example
+ * ```typescript
+ * const filterPost = createFuzzyFilter(['title', 'description']);
+ * // Matches: "jav" in "JavaScript", "scr" in "TypeScript"
+ * ```
+ */
+export function createFuzzyFilter(fields, minMatchLength = 2) {
+    return (item, query) => {
+        if (query.length < minMatchLength)
+            return true;
+        const normalizedQuery = normalizeSearchText(query);
+        return fields.some(field => {
+            const value = item[field];
+            if (typeof value === 'string') {
+                const normalizedValue = normalizeSearchText(value);
+                // Split into words and check if any word starts with the query
+                const words = normalizedValue.split(/\s+/);
+                return words.some(word => word.startsWith(normalizedQuery));
+            }
+            return false;
+        });
+    };
+}
+/**
+ * Combine multiple filter functions with AND logic
+ *
+ * @param filters - Array of filter functions to combine
+ * @returns Combined filter function
+ *
+ * @example
+ * ```typescript
+ * const hasTag = (item, tag) => item.tags.includes(tag);
+ * const matchesText = createTextFilter(['title']);
+ * const combinedFilter = combineFilters([matchesText, (item) => hasTag(item, 'featured')]);
+ * ```
+ */
+export function combineFilters(filters) {
+    return (item, query) => {
+        return filters.every(filter => filter(item, query));
+    };
+}
+/**
+ * Create a date range filter
+ *
+ * @param dateField - Field name containing the date
+ * @param startDate - Start of date range (optional)
+ * @param endDate - End of date range (optional)
+ * @returns Filter function for use with ContentSearch
+ *
+ * @example
+ * ```typescript
+ * const recentPostsFilter = createDateFilter('publishedAt', new Date('2024-01-01'));
+ * ```
+ */
+export function createDateFilter(dateField, startDate, endDate) {
+    // Date filters don't use the query string, but must match the filterFn signature
+    return (item, _query) => {
+        const dateValue = item[dateField];
+        if (!dateValue)
+            return false;
+        // Validate dateValue is a valid date type before constructing Date
+        if (typeof dateValue !== 'string' && typeof dateValue !== 'number' && !(dateValue instanceof Date)) {
+            return false;
+        }
+        const itemDate = new Date(dateValue);
+        // Check if the date is valid (invalid dates return NaN for getTime())
+        if (isNaN(itemDate.getTime()))
+            return false;
+        if (startDate && itemDate < startDate)
+            return false;
+        if (endDate && itemDate > endDate)
+            return false;
+        return true;
+    };
+}

package/dist/ui/components/forms/index.d.ts

@@ -1,2 +1,4 @@
 export { default as SearchInput } from './SearchInput.svelte';
+export { default as ContentSearch } from './ContentSearch.svelte';
+export { normalizeSearchText, includesNormalized, textIncludes, createTextFilter, createMultiFieldFilter, precomputeLowercaseFields, createFuzzyFilter, combineFilters, createDateFilter } from './filterUtils.js';
 export declare const FORMS_VERSION = "0.2.0";

package/dist/ui/components/forms/index.js

@@ -3,6 +3,10 @@
 // This module exports specialized form input components
 //
 // Usage:
-//   import { SearchInput } from '@groveengine/ui/forms';
+//   import { SearchInput, ContentSearch } from '@groveengine/ui/forms';
+//   import { createTextFilter, createMultiFieldFilter } from '@groveengine/ui/forms';
 export { default as SearchInput } from './SearchInput.svelte';
+export { default as ContentSearch } from './ContentSearch.svelte';
+// Filter utilities for ContentSearch
+export { normalizeSearchText, includesNormalized, textIncludes, createTextFilter, createMultiFieldFilter, precomputeLowercaseFields, createFuzzyFilter, combineFilters, createDateFilter } from './filterUtils.js';
 export const FORMS_VERSION = '0.2.0';

package/dist/ui/components/gallery/ImageGallery.svelte

@@ -263,10 +263,15 @@
 
 	<!-- Lightbox modal -->
 	{#if lightboxOpen}
-		<!-- svelte-ignore a11y_no_static_element_interactions a11y_click_events_have_key_events a11y_interactive_supports_focus -->
+		<!-- svelte-ignore a11y_click_events_have_key_events -->
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
 		<div
 			class="lightbox-backdrop"
 			onclick={(/** @type {MouseEvent} */ e) => e.target === e.currentTarget && closeLightbox()}
+			onkeydown={(/** @type {KeyboardEvent} */ e) => {
+				if (e.key === 'Escape') closeLightbox();
+				if (e.key === 'Enter' || e.key === ' ') closeLightbox();
+			}}
 			role="dialog"
 			aria-modal="true"
 			aria-label="Image viewer"
@@ -279,8 +284,17 @@
 				</svg>
 			</button>
 
-			<!-- svelte-ignore a11y_no_static_element_interactions a11y_click_events_have_key_events -->
-			<div class="lightbox-content" onclick={(/** @type {MouseEvent} */ e) => e.target === e.currentTarget && closeLightbox()}>
+			<!-- svelte-ignore a11y_click_events_have_key_events -->
+			<!-- svelte-ignore a11y_no_static_element_interactions -->
+			<div
+				class="lightbox-content"
+				onclick={(/** @type {MouseEvent} */ e) => e.target === e.currentTarget && closeLightbox()}
+				onkeydown={(/** @type {KeyboardEvent} */ e) => {
+					if (e.key === 'Escape') closeLightbox();
+					if (e.key === 'Enter' || e.key === ' ') closeLightbox();
+				}}
+				role="presentation"
+			>
 				<ZoomableImage
 					src={currentImage.url}
 					alt={currentImage.alt || `Image ${currentIndex + 1}`}

package/dist/ui/components/gallery/Lightbox.svelte

@@ -24,10 +24,12 @@
 <svelte:window onkeydown={handleKeydown} />
 
 {#if isOpen}
-	<!-- svelte-ignore a11y_no_static_element_interactions a11y_click_events_have_key_events a11y_interactive_supports_focus -->
+	<!-- svelte-ignore a11y_click_events_have_key_events -->
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
 	<div
 		class="lightbox-backdrop"
 		onclick={handleBackdropClick}
+		onkeydown={handleKeydown}
 		role="dialog"
 		aria-modal="true"
 		aria-label="Image viewer"
@@ -39,8 +41,14 @@
 				<line x1="6" y1="6" x2="18" y2="18"></line>
 			</svg>
 		</button>
-		<!-- svelte-ignore a11y_no_static_element_interactions a11y_click_events_have_key_events -->
-		<div class="lightbox-content" onclick={handleBackdropClick}>
+		<!-- svelte-ignore a11y_click_events_have_key_events -->
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<div
+			class="lightbox-content"
+			onclick={handleBackdropClick}
+			onkeydown={handleKeydown}
+			role="presentation"
+		>
 			<ZoomableImage {src} {alt} isActive={isOpen} class="lightbox-image" />
 		</div>
 		<LightboxCaption {caption} />

package/dist/ui/components/gallery/ZoomableImage.svelte

@@ -124,11 +124,20 @@
 		}
 		cycleZoom();
 	}
+
+	// Keyboard handler for accessibility
+	function handleKeydown(/** @type {KeyboardEvent} */ event) {
+		if (event.key === 'Enter' || event.key === ' ') {
+			event.preventDefault();
+			cycleZoom();
+		}
+	}
 </script>
 
 <svelte:window onmousemove={handleMouseMove} onmouseup={handleMouseUp} />
 
-<!-- svelte-ignore a11y_no_noninteractive_element_interactions a11y_click_events_have_key_events a11y_no_noninteractive_element_to_interactive_role -->
+<!-- svelte-ignore a11y_click_events_have_key_events -->
+<!-- svelte-ignore a11y_no_noninteractive_element_to_interactive_role -->
 <img
 	{src}
 	{alt}
@@ -141,8 +150,10 @@
 	ontouchmove={handleTouchMove}
 	ontouchend={handleTouchEnd}
 	onclick={handleClick}
-	role="button"
+	onkeydown={handleKeydown}
 	tabindex="0"
+	role="button"
+	aria-label="Click to zoom image"
 />
 
 <style>

package/dist/ui/components/icons/index.d.ts

@@ -1,3 +1,4 @@
 export { default as Icons } from './Icons.svelte';
 export { default as IconLegend } from './IconLegend.svelte';
-export declare const ICONS_VERSION = "0.2.0";
+export { navIcons, stateIcons, pricingIcons, featureIcons, growthIcons, phaseIcons, actionIcons, metricsIcons, allIcons, type IconKey, getIcon, getIconFromAll, Check, CheckCircle, X, ArrowRight, ArrowLeft, MapPin, Sprout, Trees, TreeDeciduous, Crown, Flower2, Leaf, Heart, Home, Menu, Settings, ExternalLink, ChevronDown, LogIn, Github, Mail, HardDrive, Palette, Shield, Download, Rss, Eye, MessageCircle, Loader2, AlertTriangle, HelpCircle, Lock, Sparkles, Clock, TrendingUp, Users, Activity, } from './lucide';
+export declare const ICONS_VERSION = "0.3.0";

package/dist/ui/components/icons/index.js

@@ -1,9 +1,20 @@
 // GroveUI - Icon Components
 //
-// This module exports SVG icon components used across the Grove platform
+// This module exports SVG icon components and Lucide icon registries
+// used across the Grove platform.
 //
 // Usage:
-//   import { Icons, IconLegend } from '@groveengine/ui/icons';
+//   import { Icons, IconLegend } from '@autumnsgrove/groveengine/ui/icons';
+//   import { stateIcons, pricingIcons, Check } from '@autumnsgrove/groveengine/ui/icons';
+// Custom SVG components
 export { default as Icons } from './Icons.svelte';
 export { default as IconLegend } from './IconLegend.svelte';
-export const ICONS_VERSION = '0.2.0';
+// Lucide icon registries and utilities
+export { 
+// Icon maps (semantic groupings)
+navIcons, stateIcons, pricingIcons, featureIcons, growthIcons, phaseIcons, actionIcons, metricsIcons, allIcons, 
+// Utilities
+getIcon, getIconFromAll, 
+// Direct icon exports (commonly used)
+Check, CheckCircle, X, ArrowRight, ArrowLeft, MapPin, Sprout, Trees, TreeDeciduous, Crown, Flower2, Leaf, Heart, Home, Menu, Settings, ExternalLink, ChevronDown, LogIn, Github, Mail, HardDrive, Palette, Shield, Download, Rss, Eye, MessageCircle, Loader2, AlertTriangle, HelpCircle, Lock, Sparkles, Clock, TrendingUp, Users, Activity, } from './lucide';
+export const ICONS_VERSION = '0.3.0';

package/dist/ui/components/icons/lucide.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Shared Lucide icon registry for Grove Platform.
+ * Single source of truth for commonly used icons across all Grove apps.
+ *
+ * DO: Import icons from '@autumnsgrove/groveengine/ui/icons'
+ * DON'T: Import directly from 'lucide-svelte' in app components
+ *
+ * @example
+ * ```svelte
+ * import { stateIcons, navIcons } from '@autumnsgrove/groveengine/ui/icons';
+ *
+ * <svelte:component this={stateIcons.check} class="w-5 h-5" />
+ * ```
+ */
+import { Home, Info, Telescope, MapPin, CircleDollarSign, BookOpen, Trees, PenLine, ArrowRight, ArrowLeft, ChevronRight, ChevronLeft, ChevronDown, ExternalLink, LogIn, Mail, HardDrive, Palette, ShieldCheck, Shield, Cloud, SearchCode, Archive, Upload, MessagesSquare, MessageCircle, FileText, Tag, Rss, Eye, Github, Layers, Sprout, Heart, Leaf, Flower2, TreeDeciduous, Crown, Check, CheckCircle, X, Loader2, AlertTriangle, HelpCircle, Circle, Lock, Gem, Sparkles, Star, Moon, Sun, Compass, Megaphone, Lightbulb, Download, Settings, Menu, Clock, TrendingUp, TrendingDown, Activity, Users, ShieldUser, BarChart3, Globe, CalendarDays, LifeBuoy } from 'lucide-svelte';
+/** Icons for main navigation items */
+export declare const navIcons: {
+    readonly home: typeof Home;
+    readonly about: typeof Info;
+    readonly vision: typeof Telescope;
+    readonly roadmap: typeof MapPin;
+    readonly pricing: typeof CircleDollarSign;
+    readonly knowledge: typeof BookOpen;
+    readonly forest: typeof Trees;
+    readonly blog: typeof PenLine;
+    readonly arrow: typeof ArrowRight;
+    readonly arrowLeft: typeof ArrowLeft;
+    readonly chevron: typeof ChevronRight;
+    readonly chevronLeft: typeof ChevronLeft;
+    readonly chevronDown: typeof ChevronDown;
+    readonly external: typeof ExternalLink;
+    readonly login: typeof LogIn;
+    readonly github: typeof Github;
+};
+/** Icons for states: success, error, loading, etc. */
+export declare const stateIcons: {
+    readonly check: typeof Check;
+    readonly checkcircle: typeof CheckCircle;
+    readonly x: typeof X;
+    readonly loader: typeof Loader2;
+    readonly warning: typeof AlertTriangle;
+    readonly help: typeof HelpCircle;
+    readonly info: typeof Info;
+    readonly circle: typeof Circle;
+    readonly lock: typeof Lock;
+};
+/** Icons for pricing tiers and feature comparison */
+export declare const pricingIcons: {
+    readonly sprout: typeof Sprout;
+    readonly treedeciduous: typeof TreeDeciduous;
+    readonly trees: typeof Trees;
+    readonly crown: typeof Crown;
+    readonly penline: typeof PenLine;
+    readonly filetext: typeof FileText;
+    readonly harddrive: typeof HardDrive;
+    readonly palette: typeof Palette;
+    readonly flower2: typeof Flower2;
+    readonly messagecircle: typeof MessageCircle;
+    readonly globe: typeof Globe;
+    readonly searchcode: typeof SearchCode;
+    readonly mail: typeof Mail;
+    readonly lifebuoy: typeof LifeBuoy;
+    readonly calendardays: typeof CalendarDays;
+    readonly clock: typeof Clock;
+    readonly check: typeof Check;
+};
+/** Icons for features, tools, and content types */
+export declare const featureIcons: {
+    readonly mail: typeof Mail;
+    readonly harddrive: typeof HardDrive;
+    readonly palette: typeof Palette;
+    readonly shieldcheck: typeof ShieldCheck;
+    readonly shield: typeof Shield;
+    readonly cloud: typeof Cloud;
+    readonly searchcode: typeof SearchCode;
+    readonly archive: typeof Archive;
+    readonly upload: typeof Upload;
+    readonly messagessquare: typeof MessagesSquare;
+    readonly externallink: typeof ExternalLink;
+    readonly filetext: typeof FileText;
+    readonly tag: typeof Tag;
+    readonly rss: typeof Rss;
+    readonly eye: typeof Eye;
+    readonly download: typeof Download;
+    readonly layers: typeof Layers;
+};
+/** Icons representing growth and nature (Grove themed) */
+export declare const growthIcons: {
+    readonly sprout: typeof Sprout;
+    readonly heart: typeof Heart;
+    readonly leaf: typeof Leaf;
+    readonly flower2: typeof Flower2;
+    readonly trees: typeof Trees;
+    readonly treedeciduous: typeof TreeDeciduous;
+};
+/** Icons for phases, refinement, and mystical/future content */
+export declare const phaseIcons: {
+    readonly gem: typeof Gem;
+    readonly sparkles: typeof Sparkles;
+    readonly star: typeof Star;
+    readonly moon: typeof Moon;
+    readonly sun: typeof Sun;
+    readonly sprout: typeof Sprout;
+};
+/** Icons for user actions and processes */
+export declare const actionIcons: {
+    readonly compass: typeof Compass;
+    readonly megaphone: typeof Megaphone;
+    readonly lightbulb: typeof Lightbulb;
+    readonly download: typeof Download;
+    readonly settings: typeof Settings;
+    readonly menu: typeof Menu;
+    readonly trend: typeof TrendingUp;
+    readonly trenddown: typeof TrendingDown;
+    readonly arrow: typeof ArrowRight;
+};
+/** Icons for analytics and metrics display */
+export declare const metricsIcons: {
+    readonly clock: typeof Clock;
+    readonly trending: typeof TrendingUp;
+    readonly trenddown: typeof TrendingDown;
+    readonly activity: typeof Activity;
+    readonly users: typeof Users;
+    readonly shield: typeof ShieldUser;
+    readonly barchart: typeof BarChart3;
+};
+/** All icons in one map (use specific maps above when possible) */
+export declare const allIcons: {
+    readonly clock: typeof Clock;
+    readonly trending: typeof TrendingUp;
+    readonly trenddown: typeof TrendingDown;
+    readonly activity: typeof Activity;
+    readonly users: typeof Users;
+    readonly shield: typeof ShieldUser;
+    readonly barchart: typeof BarChart3;
+    readonly compass: typeof Compass;
+    readonly megaphone: typeof Megaphone;
+    readonly lightbulb: typeof Lightbulb;
+    readonly download: typeof Download;
+    readonly settings: typeof Settings;
+    readonly menu: typeof Menu;
+    readonly trend: typeof TrendingUp;
+    readonly arrow: typeof ArrowRight;
+    readonly gem: typeof Gem;
+    readonly sparkles: typeof Sparkles;
+    readonly star: typeof Star;
+    readonly moon: typeof Moon;
+    readonly sun: typeof Sun;
+    readonly sprout: typeof Sprout;
+    readonly heart: typeof Heart;
+    readonly leaf: typeof Leaf;
+    readonly flower2: typeof Flower2;
+    readonly trees: typeof Trees;
+    readonly treedeciduous: typeof TreeDeciduous;
+    readonly mail: typeof Mail;
+    readonly harddrive: typeof HardDrive;
+    readonly palette: typeof Palette;
+    readonly shieldcheck: typeof ShieldCheck;
+    readonly cloud: typeof Cloud;
+    readonly searchcode: typeof SearchCode;
+    readonly archive: typeof Archive;
+    readonly upload: typeof Upload;
+    readonly messagessquare: typeof MessagesSquare;
+    readonly externallink: typeof ExternalLink;
+    readonly filetext: typeof FileText;
+    readonly tag: typeof Tag;
+    readonly rss: typeof Rss;
+    readonly eye: typeof Eye;
+    readonly layers: typeof Layers;
+    readonly check: typeof Check;
+    readonly checkcircle: typeof CheckCircle;
+    readonly x: typeof X;
+    readonly loader: typeof Loader2;
+    readonly warning: typeof AlertTriangle;
+    readonly help: typeof HelpCircle;
+    readonly info: typeof Info;
+    readonly circle: typeof Circle;
+    readonly lock: typeof Lock;
+    readonly home: typeof Home;
+    readonly about: typeof Info;
+    readonly vision: typeof Telescope;
+    readonly roadmap: typeof MapPin;
+    readonly pricing: typeof CircleDollarSign;
+    readonly knowledge: typeof BookOpen;
+    readonly forest: typeof Trees;
+    readonly blog: typeof PenLine;
+    readonly arrowLeft: typeof ArrowLeft;
+    readonly chevron: typeof ChevronRight;
+    readonly chevronLeft: typeof ChevronLeft;
+    readonly chevronDown: typeof ChevronDown;
+    readonly external: typeof ExternalLink;
+    readonly login: typeof LogIn;
+    readonly github: typeof Github;
+};
+/** Type for any icon key in the registry */
+export type IconKey = keyof typeof allIcons;
+/**
+ * Get an icon from a specific map by key
+ * @example
+ * ```ts
+ * const icon = getIcon(stateIcons, 'check');
+ * ```
+ */
+export declare function getIcon<T extends Record<string, any>>(map: T, key: keyof T | string): any;
+/**
+ * Get an icon from the unified map
+ * @example
+ * ```ts
+ * const icon = getIconFromAll('check');
+ * ```
+ */
+export declare function getIconFromAll(key: string): any;
+export { Check, CheckCircle, X, ArrowRight, ArrowLeft, MapPin, Sprout, Trees, TreeDeciduous, Crown, Flower2, Leaf, Heart, Home, Menu, Settings, ExternalLink, ChevronDown, LogIn, Github, Mail, HardDrive, Palette, Shield, Download, Rss, Eye, MessageCircle, Layers, Loader2, AlertTriangle, HelpCircle, Lock, Sparkles, Clock, TrendingUp, Users, Activity, };